java线程异常终止_Java线程异常结束怎么解决

Java中线程异常结束的解决方法是:首先捕获线程执行过程中所产生的异常;然后当线程异常时,会通过调用setUncaughtExceptionHandler方法来捕获异常;最后再解决即可。

b9ccc2da064c636c7bc0c78e0624b415.png

【推荐教程:Java教程】

我们开发工程中经常使用到线程,在线程使用上,我们可能会有这样的场景:

(1)伴随这一个业务产生一个比较耗时的任务,而这个业务返回并不需要等待该任务。那我们往往会启动一个线程去完成这个异步任务。

(2)我们需要一个定时任务比如:定时清除数据,我们会起一个定时执行线程去做该任务。

上述问题比较简单,new一个线程然后去做这件事。但是我们常常忽略一个问题,线程异常了怎么办?比如耗时任务我们只完成了一半,我们就异常结束了(这里不考虑事务一致性,我们只考虑一定要将任务完成)。又比如在清数据的时候,数据库发生断连。这时候我们会发现线程死掉了,任务终止了,我们需要重启整个项目把该定时任务起起来。

解决这些问题的关键就是,如何捕获线程执行过程中产生的异常?

我们查看JDK API我们会发现在Thread中有setUncaughtExceptionHandler方法,让我们可以在线程发生异常时,调用该方法。

Java中线程异常结束的解决方法是:

场景一解决思路:public class Plan1 {

private SimpleTask task = new SimpleTask();

public static void main(String[] args) {

Plan1 plan = new Plan1();

plan.start();

}

public void start(){

Thread thread = new Thread(task);

//thread.setDaemon(true); //注释调 否则看不到输出

thread.setUncaughtExceptionHandler(new UncaughtExceptionHandler(){

@Override

public void uncaughtException(Thread t, Throwable e) {

System.out.println(e.getMessage());

start();

}

});

thread.start();

}

class SimpleTask implements Runnable{

private int task = 10;

@Override

public void run() {

String threadName = Thread.currentThread().getName();

System.out.println(threadName+"--"+"启动");

while(task>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

if(System.currentTimeMillis()%3==0){

throw new RuntimeException("模拟异常");

}

System.out.println(threadName+"--"+"执行task"+task);

task--;

}

System.out.println(threadName+"--"+"正常终止");

}

}

}

结果输出:Thread-0--启动

Thread-0--执行task10

Thread-0--执行task9

Thread-0--执行task8

Thread-0--执行task7

模拟异常

Thread-1--启动

Thread-1--执行task6

Thread-1--执行task5

模拟异常

Thread-2--启动

Thread-2--执行task4

Thread-2--执行task3

模拟异常

Thread-3--启动

Thread-3--执行task2

模拟异常

Thread-4--启动

Thread-4--执行task1

Thread-4--正常终止

还是场景一我们来看一下线程池的方式,思路是一样的为什么要再写一个单线程的线程池方式呢?public class Plan3 {

private SimpleTask task = new SimpleTask();

private MyFactory factory = new MyFactory(task);

public static void main(String[] args) {

Plan3 plan = new Plan3();

ExecutorService pool = Executors.newSingleThreadExecutor(plan.factory);

pool.execute(plan.task);

pool.shutdown();

}

class MyFactory implements ThreadFactory{

private SimpleTask task;

public MyFactory(SimpleTask task) {

super();

this.task = task;

}

@Override

public Thread newThread(Runnable r) {

Thread thread = new Thread(r);

thread.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {

@Override

public void uncaughtException(Thread t, Throwable e) {

ExecutorService pool = Executors.newSingleThreadExecutor(new MyFactory(task));

pool.execute(task);

pool.shutdown();

}

});

return thread;

}

}

class SimpleTask implements Runnable{

private int task = 10;

@Override

public void run() {

String threadName = Thread.currentThread().getName();

System.out.println(threadName+"--"+"启动");

while(task>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

if(System.currentTimeMillis()%3==0){

throw new RuntimeException("模拟异常");

}

System.out.println(threadName+"--"+"执行task"+task);

task--;

}

System.out.println(threadName+"--"+"正常终止");

}

}

}

结果输出:Thread-0--启动

Thread-0--执行task10

Thread-0--执行task9

Thread-1--启动

Thread-1--执行task8

Thread-2--启动

Thread-2--执行task7

Thread-2--执行task6

Thread-2--执行task5

Thread-2--执行task4

Thread-2--执行task3

Thread-2--执行task2

Thread-3--启动

Thread-3--执行task1

Thread-3--正常终止

由于这边只是用单线程,所以发现和上面区别不大。不过也展示了线程池是如何捕获线程异常的。

场景二解决方法

现在我们看看场景二定时任务,为什么我要写一份单线程池的捕获异常方式,就是用于和下面做对比。

定时任务我们常常用ScheduledExecutorService,和上述ExecutorService获取方式一样。但是如果我们参照上述方式写定时任务,然后获取异常。我们会发现我们无法在uncaughtException方法内获取到线程的异常。异常消失了,或者说线程发生异常根本就没调用uncaughtException方法。后来查看相关API,发现在ScheduledExecutorService获取异常的方式可以使用ScheduledFuture对象来获取具体方式如下:public class Plan2 {

private SimpleTask task = new SimpleTask();

public static void main(String[] args) {

Plan2 plan = new Plan2();

start(plan.task);

}

public static void start(SimpleTask task){

ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();

ScheduledFuture> future = pool.scheduleAtFixedRate(task, 0, 1000, TimeUnit.MILLISECONDS);

try {

future.get();

} catch (InterruptedException | ExecutionException e) {

System.out.println(e.getMessage());

start(task);

}finally {

pool.shutdown();

}

}

class SimpleTask implements Runnable{

private volatile int count = 0;

@Override

public void run() {

String threadName = Thread.currentThread().getName();

System.out.println(threadName+"--"+"启动");

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

if(System.currentTimeMillis()%3==0){

throw new RuntimeException("模拟异常");

}

System.out.println(threadName+"--"+"执行task"+count);

count++;

System.out.println(threadName+"--"+"正常终止");

}

}

}

结果输出:pool-1-thread-1--启动

java.lang.RuntimeException: 模拟异常

pool-2-thread-1--启动

pool-2-thread-1--执行task0

pool-2-thread-1--正常终止

pool-2-thread-1--启动

pool-2-thread-1--执行task1

pool-2-thread-1--正常终止

pool-2-thread-1--启动

pool-2-thread-1--执行task2

pool-2-thread-1--正常终止

pool-2-thread-1--启动

java.lang.RuntimeException: 模拟异常

pool-3-thread-1--启动

pool-3-thread-1--执行task3

pool-3-thread-1--正常终止

pool-3-thread-1--启动

java.lang.RuntimeException: 模拟异常

pool-4-thread-1--启动

pool-4-thread-1--执行task4

pool-4-thread-1--正常终止

.....

至此我们实现了就算定时任务发生异常,总有一个线程会去执行。一个线程倒下,会有后续线程补上。

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值