线程异常如何处理？试试这样

点击上方 Java后端，选择 设为星标

优质文章，及时送达

---

作者：何甜甜在吗

https://juejin.im/post/6844903997388636174

之前使用线程执行任务的时候，总是忽略了线程异常的处理，直到最近看书

线程出现异常测试

任务类：Task.java

public class Task implements Runnable {
  private int i;

  public Task(int i) {
    this.i = i;
  }

  @Override
  public void run() {
    if (i == 5) {
      //System.out.println("throw exception");
      throw new IllegalArgumentException();
    }
    System.out.println(i);
  }
}

如果 i==5，将抛出一个异常

线程测试类：TaskTest.java

public class TestTask {
  public static void main(String[] args) {
    int i = 0;
    while (true) {
      if (i == 10) break;
      try {
        new Thread(new Task(i++)).start();
      } catch (Exception e) {
        System.out.println("catch exception...");
      }
    }
  }
}

通过使用 try-catch，尝试对抛出的异常进行捕获

测试结果

Connected to the target VM, address: '127.0.0.1:64551', transport: 'socket'
0
1
2
3
4
6
7
8
9
Exception in thread "pool-1-thread-1" java.lang.IllegalArgumentException
  at com.h2t.study.thread.Task.run(Task.java:21)
  at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
  at java.lang.Thread.run(Thread.java:748)

异常没有被捕获，只是在控制台打印了异常，并且不影响后续任务的执行 emmmm 这是为什么呢，捕获不到异常就不知道程序出错了，到时候哪天有个任务不正常排查都排查不到，这样是要不得的。看一下 Thread 这个类，有个叫 dispatchUncaughtException 的方法，作用如其名，分发未捕获的异常，把这段代码揪出来：Thread#dispatchUncaughtException

private void dispatchUncaughtException(Throwable e) {
  getUncaughtExceptionHandler().uncaughtException(this, e);
}

find usage 是找不到该方法在哪里调用的，因为这个方法只被 JVM 调用 Thread#getUncaughtExceptionHandler： 获取 UncaughtExceptionHandler 接口实现类

public UncaughtExceptionHandler getUncaughtExceptionHandler() {
  return uncaughtExceptionHandler != null ?
    uncaughtExceptionHandler : group;
}

UncaughtExceptionHandler 是 Thread 中定义的接口，在 Thread 类中 uncaughtExceptionHandler 默认是 null，因此该方法将返回 group，即实现了 UncaughtExceptionHandler 接口的 ThreadGroup 类 UncaughtExceptionHandler#uncaughtException： ThreadGroup 类的 uncaughtException 方法实现

public void uncaughtException(Thread t, Throwable e) {
    if (parent != null) {
        parent.uncaughtException(t, e);
    } else {
        Thread.UncaughtExceptionHandler ueh =
            Thread.getDefaultUncaughtExceptionHandler();
        if (ueh != null) {
            ueh.uncaughtException(t, e);
        } else if (!(e instanceof ThreadDeath)) {
            System.err.print("Exception in thread \""
                             + t.getName() + "\" ");
            e.printStackTrace(System.err);
        }
    }
}

因为在 Thread 类中没有对 group【parent】和 defaultUncaughtExceptionHandler【Thread.getDefaultUncaughtExceptionHandler】进行赋值，因此将进入最后一层条件，将异常打印到控制台中，对异常不做任何处理。整个异常处理器调用链如下：

首先判断默认异常处理器【defaultUncaughtExceptionHandler】是不是为 null，在判断线程组异常处理器【group】是不是为 null，在判断自定义异常处理器【uncaughtExceptionHandler】是不是为 null，都为 null 则在控制台打印异常

线程异常处理

分析了一下源码就知道如果想对任务执行过程中的异常进行处理一个就是让 ThreadGroup 不为 null，另外一种思路就是让 UncaughtExceptionHandler 类型的变量值不为 null。

• 异常处理器：ExceptionHandler.java

private static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
  @Override
  public void uncaughtException(Thread t, Throwable e) {
    System.out.println("异常捕获到了：" + e);
  }
}

• 设置默认异常处理器

Thread.setDefaultUncaughtExceptionHandler((t, e) -> System.out.println("异常捕获到 了: " + e));
int i = 0;
while (true) {
  if (i == 10) break;
  Thread thread = new Thread(new Task(i++));
  thread.start();
}

打印结果：

0
2
1
3
9
6
7
4
异常捕获到了：java.lang.IllegalArgumentException
8

通过设置默认异常就不需要为每个线程都设置一次了

• 设置自定义异常处理器

Thread t = new Thread(new Task(i++));
t.setUncaughtExceptionHandler(new ExceptionHandler());

打印结果：

0
2
4
异常捕获到了：java.lang.IllegalArgumentException
6
1
3
7
9
8

设置线程组异常处理器

MyThreadGroup myThreadGroup = new MyThreadGroup("测试线程线程组");
Thread t = new Thread(myThreadGroup, new Task(i++))

自定义线程组：MyThreadGroup.java

private static class MyThreadGroup extends ThreadGroup {
  public MyThreadGroup(String name) {
    super(name);
  }

  @Override
  public void uncaughtException(Thread t, Throwable e) {
    System.out.println("捕获到异常了：" + e);
  }
}

打印结果：

1
2
0
4
3
6
7
8
9
捕获到异常了：java.lang.IllegalArgumentException

线程组异常捕获处理器很适合为线程进行分组处理的场景，每个分组出现异常的处理方式不相同 设置完异常处理器后异常都能被捕获了，但是不知道为什么设置异常处理器后任务的执行顺序乱了，难道是因为为每个线程设置异常处理器的时间不同【想不通】

线程池异常处理

一般应用中线程都是通过线程池创建复用的，因此对线程池的异常处理就是为线程池工厂类【ThreadFactory 实现类】生成的线程添加异常处理器

• 默认异常处理器

Thread.setDefaultUncaughtExceptionHandler(new  ExceptionHandler());
 ExecutorService es = Executors.newCachedThreadPool();
es.execute(new Task(i++))

• 自定义异常处理器

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>());
threadPoolExecutor.setThreadFactory(new MyThreadFactory());
threadPoolExecutor.execute(new Task(i++));

自定义工厂类：MyThreadFactory.java

private static class MyThreadFactory implements ThreadFactory {
  @Override
  public Thread newThread(Runnable r) {
    Thread t = new Thread();
    //自定义UncaughtExceptionHandler
    t.setUncaughtExceptionHandler(new ExceptionHandler());
    return t;
   }
}

设计原则，为什么要由线程自身进行捕获

来自 JVM 的设计理念 " 线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部 "。因此在 Java 中，线程方法的异常【即任务抛出的异常】，应该在线程代码边界之内处理掉，而不应该在线程方法外面由其他线程处理

线程执行 Callable 任务

前面介绍的是线程执行 Runnable 类型任务的情况，众所周知，还有一种有返回值的 Callable 任务类型 测试代码：TestTask.java

public class TestTask {
    public static void main(String[] args) {
        int i = 0;
        while (true) {
            if (i == 10) break;
            FutureTask<Integer> task = new FutureTask<>(new CallableTask(i++));
            Thread thread = new Thread(task);
            thread.setUncaughtExceptionHandler(new ExceptionHandler());
            thread.start();
        }
    }
    
    private static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            System.out.println("异常捕获到了：" + e);
        }
    }
}

打印结果：

Disconnected from the target VM, address: '127.0.0.1:64936', transport: 'socket'
0
1
2
3
4
6
7
8
9

观察结果，异常没有被捕获，thread.setUncaughtExceptionHandler(new ExceptionHandler()) 方法设置无效，emmmmm，这又是为什么呢，在问为什么就是十万个为什么儿童了。查看 FutureTask 的 run 方法，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 {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

FutureTask#setException：

protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
      //将异常设置给outcome变量
      outcome = t;
      //设置任务的状态为EXCEPTIONAL
      UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
      finishCompletion();
    }
}

看到 catch 这段代码，当执行任务捕获到异常的时候，会将任务的处理结果设置为 null，并且调用 setException 方法对捕获的异常进行处理，因为 setUncaughtExceptionHandler 只对未捕获的异常进行处理，FutureTask 已经对异常进行了捕获处理，因此调用 setUncaughtExceptionHandler 捕获异常无效 对任务的执行结果调用 get 方法：

int i = 0;
while (true) {
    if (i == 10) break;
    FutureTask<Integer> task = new FutureTask<>(new CallableTask(i++));
    Thread thread = new Thread(task);
    thread.setUncaughtExceptionHandler(new ExceptionHandler());
    thread.start();
    //打印结果
    try {
    System.out.println(task.get());
    } catch (Exception e) {
      System.out.println("异常被抓住了, e: " + e);
    }
}

执行结果将会将捕获到的异常打印出来，执行结果：

0
1
2
3
4
异常被抓住了, e: java.util.concurrent.ExecutionException: java.lang.IllegalArgumentException
6
7
Disconnected from the target VM, address: '127.0.0.1:50900', transport: 'socket'
8
9

FutureTask#get：

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
      //未完成等待任务执行完成
      s = awaitDone(false, 0L);
    return report(s);
}

FutureTask#report：

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);
}

outcome 在 setException 方法中被设置为了异常，并且 s 为 state 的状态最终 8 被设置为 EXCEPTIONAL，因此方法将捕获的任务抛出【new ExecutionException((Throwable)x)】
总结：
Callable 任务抛出的异常能在代码中通过 try-catch 捕获到，但是只有调用 get 方法后才能捕获到

---

-END-

如果看到这里，说明你喜欢这篇文章，请 转发、点赞。同时 标星（置顶）本公众号可以第一时间接受到博文推送。

推荐阅读

1. 采用 Vue 编写的功能强大的 Swagger-ui 页面

2. 永远不要在代码中使用「User」这个单词！

3. Nginx + Spring Boot 实现负载均衡

4. Spring Boot+Redis实现接口自动幂等

最近整理一份面试资料《Java技术栈学习手册》，覆盖了Java技术、面试题精选、Spring全家桶、Nginx、SSM、微服务、数据库、数据结构、架构等等。

获取方式：点“ 在看，关注公众号 Java后端 并回复 777 领取，更多内容陆续奉上。

喜欢文章，点个在看