使用UncaughtExceptionHandler重启线程

简介: 使用UncaughtExceptionHandler重启线程 我们已经知道,Java中有两种异常,即已检测异常和未检测异常。

使用UncaughtExceptionHandler重启线程

我们已经知道,Java中有两种异常,即已检测异常和未检测异常。已检测的异常必须在抛出语句(throws clause)的方法中指定或者捕获。未检测的异常不需要指定或捕获。因为run()方法不接受抛出语句,所以当一个检测的异常在一个Thread对象的 run()方法中抛出,我们需要对其进行捕获并做相应的处理。但是当一个未检测的异常在一个线程的run()方法中抛出,默认的行为是将堆栈跟踪信息写到 控制台中(或者记录到错误日志文件中)然后退出程序。

幸运的是,Java为我们提供了一个机制,用来捕获并处理在一个线程对象中抛出的未检测异常,以避免程序终止。我们可以通过UncaughtExceptionHandler来实现这种机制。

让我们来做个UncaughtExceptionHandler的使用 示例。在这个例子中,我们已经创建一个线程,这个线程尝试解析一些本来应该是整数的字符串。我们已经写出run()方法,让它在执行时抛出 java.lang.NumberFormatException。当程序不去捕获异常时,异常经过JVM的同时线程也被杀死。这确实属于正常的行为,但 不是我们希望看到的。

不使用UncaughtExceptionHandler

在现实生活的应用中,对于一个关键的任务,虽然已经失败了几次,但是你依然愿意尝试再执行几次。下面的例子解释了这个用例,首先不使用UncaughtExceptionHandler时,线程在执行失败之后立即终止。

Task.java

1
2
3
4
5
6
7
8
9
10
11
12
class Task implements Runnable
{
    @Override
    public void run()
    {
       System.out.println(Integer.parseInt( "123" ));
       System.out.println(Integer.parseInt( "234" ));
       System.out.println(Integer.parseInt( "345" ));
       System.out.println(Integer.parseInt( "XYZ" )); //This will cause NumberFormatException
       System.out.println(Integer.parseInt( "456" ));
    }
}

DemoThreadExample.java

1
2
3
4
5
6
7
8
9
public class DemoThreadExample
{
    public static void main(String[] args)
    {
       Task task = new Task();
       Thread thread = new Thread(task);
       thread.start();
    }
}

下面是线程运行时的输出:

1
2
3
4
5
6
7
8
9
123
234
345
Exception in thread "Thread-0" java.lang.NumberFormatException: For input string: "XYZ"
     at java.lang.NumberFormatException.forInputString(Unknown Source)
     at java.lang.Integer.parseInt(Unknown Source)
     at java.lang.Integer.parseInt(Unknown Source)
     at examples.algorithms.sleepingbarber.Task.run(DemoThreadExample.java:24)
     at java.lang.Thread.run(Unknown Source)

使用UncaughtExceptionHandler之后

首先,我们实现UncaughtExceptionHandler接口,用来捕获运行时的任意未检测的异常。

ExceptionHandler.java

1
2
3
4
5
6
7
8
9
10
11
12
13
class ExceptionHandler implements UncaughtExceptionHandler
{
    public void uncaughtException(Thread t, Throwable e)
    {
       System.out.printf( "An exception has been capturedn" );
       System.out.printf( "Thread: %sn" , t.getId());
       System.out.printf( "Exception: %s: %sn" , e.getClass().getName(), e.getMessage());
       System.out.printf( "Stack Trace: n" );
       e.printStackTrace(System.out);
       System.out.printf( "Thread status: %sn" , t.getState());
       new Thread( new Task()).start();
    }
}

将异常处理程序添加到线程:

1
2
3
4
5
6
7
8
9
10
11
12
13
class Task implements Runnable
{
    @Override
    public void run()
    {
       Thread.currentThread().setUncaughtExceptionHandler( new ExceptionHandler());
       System.out.println(Integer.parseInt( "123" ));
       System.out.println(Integer.parseInt( "234" ));
       System.out.println(Integer.parseInt( "345" ));
       System.out.println(Integer.parseInt( "XYZ" )); //This will cause NumberFormatException
       System.out.println(Integer.parseInt( "456" ));
    }
}

再次运行上面的例子,会发现线程能够持续执行。实际上,如果线程完成了任务,那么它在退出时不会抛出任何异常,从而完成自身生命周期。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
123
234
345
An exception has been captured
Thread: 1394
Exception: java.lang.NumberFormatException: For input string: "XYZ"
Stack Trace:
java.lang.NumberFormatException: For input string: "XYZ"
     at java.lang.NumberFormatException.forInputString(Unknown Source)
     at java.lang.Integer.parseInt(Unknown Source)
     at java.lang.Integer.parseInt(Unknown Source)
     at examples.algorithms.sleepingbarber.Task.run(DemoThreadExample.java:24)
     at java.lang.Thread.run(Unknown Source)
Thread status: RUNNABLE
123
234
345
An exception has been captured
Thread: 1395
Exception: java.lang.NumberFormatException: For input string: "XYZ"
Stack Trace:
java.lang.NumberFormatException: For input string: "XYZ"
     at java.lang.NumberFormatException.forInputString(Unknown Source)
     at java.lang.Integer.parseInt(Unknown Source)
     at java.lang.Integer.parseInt(Unknown Source)
     at examples.algorithms.sleepingbarber.Task.run(DemoThreadExample.java:24)
     at java.lang.Thread.run(Unknown Source)
Thread status: RUNNABLE
123
234
345

上面的程序实现帮你运行一个线程,在完成任务之前,这个线程会持续运行。通过其他多线程的思想同样可以实现这种情况。

请注意:UncaughtExceptionHandler可以在无需重启线程的条件下,将日志记录变得更加健壮,因为默认日志在线程执行失败时,不会提供足够的上下文信息。

学习愉快!

原文链接:  howtodoinjava  翻译:  ImportNew.com  Angus
译文链接:  http://www.importnew.com/14434.html
目录
相关文章
|
3月前
|
消息中间件 存储 Java
服务重启了,如何保证线程池中的数据不丢失?
【8月更文挑战第30天】为确保服务重启时线程池数据不丢失,可采用数据持久化(如数据库或文件存储)、使用可靠的任务队列(如消息队列或分布式任务队列系统)、状态监测与恢复机制,以及分布式锁等方式。这些方法能有效提高系统稳定性和可靠性,需根据具体需求选择合适方案并进行测试优化。
202 5
|
Android开发
Android使用Thread的interrupt与sleep,重启或暂停线程任务
Android使用Thread的interrupt与sleep,重启或暂停线程任务 本文给出一个例子,简单说明如何在Android诸如Activity中,重启或者暂停一个正在无限运作的线程。
1795 0
|
Java Android开发
Android Priority Job Queue (Job Manager):线程任务的容错重启机制(二)
 Android Priority Job Queue (Job Manager):线程任务的容错重启机制(二) 附录文章4简单介绍了如何启动一个后台线程任务,Android Priority Job Queue (Job Manager)有一个重要的机制在附录文章4还没有体现:线程任务失败后重试、重启线程任务。
856 0
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
48 1
C++ 多线程之初识多线程
|
2月前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
20 3
|
2月前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
19 2
|
2月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
31 2
|
2月前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
34 1
|
2月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
38 1
|
2月前
|
Java
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件成立时被唤醒,从而有效解决数据一致性和同步问题。本文通过对比其他通信机制,展示了 `wait()` 和 `notify()` 的优势,并通过生产者-消费者模型的示例代码,详细说明了其使用方法和重要性。
26 1