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线程异常结束怎么解决的详细内容,更多请关注php中文网其它相关文章!
已抢48520个
抢已抢3654个
抢已抢1479个
抢已抢1624个
抢已抢2372个
抢已抢3240个
抢