写点什么

☕【Java 技术指南】「技术盲区」看看线程以及线程池的异常处理机制都有哪些?

发布于: 2021 年 10 月 15 日
☕【Java技术指南】「技术盲区」看看线程以及线程池的异常处理机制都有哪些?

线程异常捕获问题

Java 异常在线程之间不是共享的,在线程中抛出的异常是线程自己的异常,主线程并不能捕获到。也就是说你把线程执行的代码看成另一个主函数。


上面 A 和 B 的运行是互相独立的,虽然说你看到 B 所在代码块的函数内容在 main 中,但是 main 并不能捕获到这个 Runnable 里函数的异常,因为它不在同一个线程之中运行,B 中抛出的异常如果你不在另一个线程捕获的话,相当于就是没有异常处理,无法捕获。


在 java 多线程程序中,所有线程都不允许抛出未捕获的 checked exception,也就是说各个线程需要自己将 checked exception 处理掉,run 方法上面进行了约束,不可以抛出异常(throws Exception)


public class ThreadSample implements Runnable {    @Override    public void run() {  //run()方法上不可以抛出异常        System.out.println("任务开始执行");        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        int i = 10 /0;  //这里抛出RuntimeException()        System.out.println("任务执行结束");    }}
public class ThreadErrorTest { public static void main(String[] args) { Thread a = new Thread(new ThreadSample()); a.start(); System.out.println("主线程执行结束!!!"); }}
复制代码


  • a 线程运行抛出异常不会影响主线程的执行,当此类异常产生时,子线程就会终结。

  • 所以,无法在主线程中捕获子线程抛出的异常进行处理,只能在 run 方法内部对业务逻辑进行 try/catch。

  • 线程是独立执行的代码片断,线程的问题应该由线程自己来解决,而无法委托到外部。

对于线程的设置异常捕捉器

Thread 中 Java 提供了一个 setUncaughtExceptionHandler 的方法来设置线程的异常处理函数,你可以把异常处理函数传进去,当发生线程的未捕获异常的时候,由 JVM 来回调执行。

如何在获取子线程内部的线程错误执行结果呢?

  • 可以使用 Thread.UncaughtExceptionHandler 为每个线程设置异常处理器,Thread.UncaughtExceptionHandler.uncaughtException()方法会在线程因未捕获的异常而面临死亡时被调用,上述子线程本身因为异常终止打印到控制台也是由于 UncaughtExceptionHandler

  • 实现 UncaughtExceptionHandler 接口并重写 uncaughtException 方法,在 uncaughtException 方法中打印日志即可:


public class ThreadErrorTest {
public static void main(String[] args) { Thread a = new Thread(new ThreadSample()); a.setUncaughtExceptionHandler(new RuntimeExceptionHandle()); a.start(); System.out.println("主线程执行结束!!!"); }}
public class RuntimeExceptionHandle implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { //打印异常信息到日志 System.out.println("异常处理器调用, 打印日志: " + e); }}
复制代码


子线程在抛出运行时异常,调用自定义的异常处理器,进行异常处理(日志打印)

原理分析

  1. 当一个线程因未捕获的异常而即将终止时,JAVA 虚拟机将使用 Thread.getUncaughtExceptionHandler()查询该线程以获得其 UncaughtExceptionHandler

  2. 调用该 handler 的 uncaughtException()方法,将线程和异常作为参数传递。

  3. 如果没有,则搜索该线程的 ThreadGroup 的异常处理器。

  4. ThreadGroup 中的默认异常处理器实现是将处理工作逐层委托给上层的 ThreadGroup,直到某个 ThreadGroup 的异常处理器能够处理该异常,否则一直传递到顶层的 ThreadGroup。

  5. 顶层 ThreadGroup 的异常处理器委托给默认的系统处理器(如果默认的处理器存在,默认情况下为空),否则把栈信息输出到 System.err

线程池的异常捕获方式?

下面给线程池对于不可捕捉异常也提供了多种方式去处理:
  1. run 方法里面 try/catch 所有处理逻辑


public void run() {   try {    //处理逻辑   } catch(Exeception e) {      //打印日志    }}
复制代码


这是一种简单而且不易出错的线程池异常处理方式,推荐使用。


  1. 重写 ThreadPoolExecutor.afterExecute 方法


线程池的线程在执行结束前肯定调用 afterExecute 方法,所有只需要重写该方法即可。


public class MyThreadPool extends ThreadPoolExecutor {       public MyThreadPool(int corePoolSize, int maximumPoolSize,                        long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);    }
@Override public void afterExecute(Runnable r, Throwable t) { if(t != null) { System.out.println("打印异常日志:" + t); } }}
复制代码


  • 分析线程池源码:


public void execute(Runnable command) {    if (command == null)        throw new NullPointerException();    int c = ctl.get();    if (workerCountOf(c) < corePoolSize) {        if (addWorker(command, true))            return;        c = ctl.get();    }    if (isRunning(c) && workQueue.offer(command)) {        int recheck = ctl.get();        if (! isRunning(recheck) && remove(command))            reject(command);        else if (workerCountOf(recheck) == 0)            addWorker(null, false);    }    else if (!addWorker(command, false))        reject(command);}/*** addWorker方法部分内容*/w = new Worker(firstTask); //封装成Worker对象final Thread t = w.thread;if (t != null) {    final ReentrantLock mainLock = this.mainLock;    mainLock.lock();    try {        // Recheck while holding lock.        // Back out on ThreadFactory failure or if        // shut down before lock acquired.        int rs = runStateOf(ctl.get());        if (rs < SHUTDOWN ||            (rs == SHUTDOWN && firstTask == null)) {            if (t.isAlive()) // precheck that t is startable                throw new IllegalThreadStateException();            workers.add(w);            int s = workers.size();            if (s > largestPoolSize)                largestPoolSize = s;            workerAdded = true;        }    } finally {        mainLock.unlock();    }    if (workerAdded) {        t.start();        workerStarted = true;    }/*** worker对象里面的run方法部分内容*/while (task != null || (task = getTask()) != null) {    w.lock();     if ((runStateAtLeast(ctl.get(), STOP) ||          (Thread.interrupted() &&           runStateAtLeast(ctl.get(), STOP))) &&         !wt.isInterrupted())         wt.interrupt();     try {         beforeExecute(wt, task);         Throwable thrown = null;         try {             task.run();         } catch (RuntimeException x) {             thrown = x; throw x;         } catch (Error x) {             thrown = x; throw x;         } catch (Throwable x) {             thrown = x; throw new Error(x);         } finally {             afterExecute(task, thrown); //执行改方法         }     } finally {         task = null;         w.completedTasks++;         w.unlock();     } }
复制代码


  • 首先 ThreadPoolExecutor 中 execute 方法会将传入的 task 封装成 Worker 对象,在进入 Worker 对象的 run 方法,发现异常被线程池捕获了。

  • 但是最后在 finally 会执行 afterExecute(task, thrown)方法,该方法的方法体是空,里面没有任何逻辑。


  1. 使用 submit 执行任务


我们知道在使用 submit 执行任务,该方法将返回一个 Future 对象,不仅仅是任务的执行结果,异常也会被封装到 Future 对象中,通过 get()方法获取。


public Future<?> submit(Runnable task) {        if (task == null) throw new NullPointerException();        RunnableFuture<Void> ftask = newTaskFor(task, null);        execute(ftask); //封装成FutureTask对象交给execute方法        return ftask;}
复制代码


由于调用 ThreadPoolExecutor 的 execute 方法,会被封装成 Worker 对象,然后调用 FutureTask 对象的 run 方法:


public void run() {  if (state != NEW ||       !UNSAFE.compareAndSwapObject(this, runnerOffset,                                    null, Thread.currentThread()))       return;   try {       Callable<V> c = callable;       if (c != null && state == NEW) {           V result;           boolean ran;           try {               result = c.call();               ran = true;           } catch (Throwable ex) {               result = null;               ran = false;               setException(ex);  //捕获异常           }           if (ran)               set(result);       }   } finally{   ...... }
复制代码


捕获异常后调用 setException(ex)方法,setExcetion 首先是将一个异常信息赋值给一个全局变量 outcome,并且将全局的任务状态 state 字段通过 CAS 更新为 3(异常状态)然后最后做一些清理工作。


FutureTask.get()方法中,会对 setException 方法中设置的 outcome 和 state 做一些逻辑判断,然后直接往上抛出了异常,所以我们就可以在主线程中捕获这个异常。


public V get() throws InterruptedException, ExecutionException {   int s = state;     if (s <= COMPLETING)         s = awaitDone(false, 0L);     return report(s); }
private V report(int s) throws ExecutionException { Object x = outcome; if (s == NORMAL) return (V)x; if (s >= CANCELLED) throw new CancellationException(); throw new ExecutionException((Throwable)x); }
复制代码

自定义异常处理器

由于线程池传入的参数是 Runnable 不是 Thread,执行一个个对应的任务,所以这里我们需要使用 ThreadFactory 创建线程池


public class MyThreadFactory implements ThreadFactory {    @Override    public Thread newThread(Runnable r) {        Thread t = new Thread(r);        t.setUncaughtExceptionHandler(new RuntimeExceptionHandle());        return t;    }}
复制代码


继承 ThreadFactory,并重写 newThread(Runnable r)方法设置异常处理器,在异常处理器中捕获并处理异常(打印日志)


public class ThreadPoolExecption1 {    private static ExecutorService executor = Executors.newSingleThreadExecutor(new MyThreadFactory());
public static void main(String[] args) { Task task = new Task(); executor.execute(task); executor.submit(task); }}
复制代码


这种方法比较麻烦,更简单的是在 Thread 类中设置一个静态域,并将这个处理器设置为默认异常处理器,但是,这个属于全局化的,慎用!如果需要定制化,还需要专门定制。


public class ThreadPoolException2 {
private static ExecutorService executor = Executors.newFixedThreadPool(3);
public static void main(String[] args) { Thread.setDefaultUncaughtExceptionHandler(new RuntimeExceptionHandle()); Task task = new Task(); executor.execute(task); //executor.submit(task); }}
复制代码


发布于: 2021 年 10 月 15 日阅读数: 46
用户头像

🏆 2021年InfoQ写作平台-签约作者 🏆 2020.03.25 加入

【个人简介】酷爱计算机技术、醉心开发编程、喜爱健身运动、热衷悬疑推理的”极客狂人“ 【技术格言】任何足够先进的技术都与魔法无异 【技术范畴】Java领域、Spring生态、MySQL专项、APM专题及微服务/分布式体系等

评论

发布
暂无评论
☕【Java技术指南】「技术盲区」看看线程以及线程池的异常处理机制都有哪些?