Java 捕获并处理线程异常：Thread线程异常捕获、ThreadPoolExecutor线程池异常捕获

---

通过Thread.UncaughtExceptionHandler捕获线程异常

Thread.UncaughtExceptionHandler类的作用：捕获并处理线程run方法抛出的异常。

使用示例

1. 为单个线程设置异常捕获

Thread.UncaughtExceptionHandler exceptionHandler = (t, e) -> {
    System.out.println("报错线程:" + t.getName());
    System.out.println("线程抛出的异常:" + e);
};
Thread thread = new Thread(() -> {
    throw new RuntimeException("throw a new Exception ! ");
});
thread.setUncaughtExceptionHandler(exceptionHandler); // 设置异常处理器
thread.start();

2. 如果项目中，全局的Thread线程处理异常的方式都相同，那么可以设置一个全局的异常捕获类。

Thread.UncaughtExceptionHandler exceptionHandler = (t, e) -> {
    System.out.println("报错线程:" + t.getName());
    System.out.println("线程抛出的异常:" + e);
};
Thread.setDefaultUncaughtExceptionHandler(exceptionHandler);

通过这种方式，后续的Thread都可以公用这个异常处理类。如果需要用其它方式处理异常时，只需要实现1中的内容即可。

部分源码解析

• UncaughtExceptionHandler源码

// Thread.UncaughtExceptionHandler 
@FunctionalInterface
public interface UncaughtExceptionHandler {
    void uncaughtException(Thread t, Throwable e);
}

• Thread中的UncaughtExceptionHandler属性

// 作用于当个Thread线程
private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
// static修饰，其可以作用于所有Thread线程
private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;

• 在Thread中，会首先提供Thread私有的异常处理类，然后才是全局

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

实现原理

1. 当线程由于未捕获的异常而即将终止时，Java虚拟机将使用调用线程的getUncaughtExceptionHandler方法，以此来获取UncaughtExceptionHandler类，并执行其对异常的处理方法。

2. 如果一个线程没有显式实现UncaughtExceptionHandler ，那么它的ThreadGroup对象将充当它的UncaughtExceptionHandler类。

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

3. ThreadGroup实现了UncaughtExceptionHandler类。

public class ThreadGroup implements Thread.UncaughtExceptionHandler {
	// ……
	public void uncaughtException(Thread t, Throwable e) {
		// 父级ThreadGroup的处理方法
	    if (parent != null) {
	        parent.uncaughtException(t, e);
	    } else {
	    	// Thread 的全局默认处理方法
	        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);
	        }
	    }
	}
	// ……
}

---

ThreadPoolExecutor线程池异常捕获

使用示例

要捕获ThreadPoolExecutor线程池中的线程执行异常，需要实现被protected修饰的方法afterExecute，在该方法里面处理异常即可。

// ThreadPoolExecutor#afterExecute
class ExtendedExecutor extends ThreadPoolExecutor {
  protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    // 如果Runnable是Future类型，那么异常将会直接通过Future返回
    if (t == null && r instanceof Future<?>) {
      try {
        Object result = ((Future<?>) r).get();
      } catch (CancellationException ce) {
          t = ce;
      } catch (ExecutionException ee) {
          t = ee.getCause();
      } catch (InterruptedException ie) {
          Thread.currentThread().interrupt(); // ignore/reset
      }
    }
    // 非Future类型
    if (t != null)
      System.out.println(t);
  }
}

注意：实现afterExecute方法时，要正确嵌套多个覆盖，子类通常应在此方法的开头调用super.afterExecute，以确保不会破坏其他父类方法的实现。

源码解析

1. 在ThreadPoolExecutor中，线程任务的实际执行方法是runWorker，如下所示：

// ThreadPoolExecutor#runWorker
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask; // 实际提交的任务
            // …………
            try {
                beforeExecute(wt, task); // 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); // task执行后的操作，也就包括了异常的捕获工作
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        // ……
}

2. afterExecute方法在ThreadPoolExecutor，并没有进行任何操作，就是对异常的线程静默处理

// ThreadPoolExecutor#afterExecute
protected void afterExecute(Runnable r, Throwable t) { }

3. Callable类型的任务，在执行时会自己捕获并维护执行中的异常。

// AbstractExecutorService#submit
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

// Callable任务会被封装成FutureTask
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

在FutureTask的run方法中，他们内部会将整个任务用try-catch给包起来。因此，也不会抛出Callable#run执行的内部异常。

// FutureTask#run
public void run() {
	// ……
    try {
        Callable<V> c = callable;
        // ……
            // 这里将Callable的执行过程产生的异常都捕获了
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
// ……