Java线程异常结束怎么解决

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

【推荐教程：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--正常终止 .....

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

以上就是Java线程异常结束怎么解决的详细内容，更多内容请关注技术你好其它相关文章！