问题描述：
最近项目中一些异步执行的逻辑没有运行异常却没有打出日志 给定位问题带来麻烦？？
问题分析
final void runWorker(Worker w)
1. //省略无关部分
2. try {
3. beforeExecute(wt, task);
4. Throwable thrown = null;
5. try {
6. task.run(); //执行程序逻辑
7. } catch (RuntimeException x) { //捕获RuntimeException
8. thrown = x; throw x;
9. } catch (Error x) { //捕获Error
10. thrown = x; throw x;
11. } catch (Throwable x) { //捕获Throwable
12. thrown = x; throw new Error(x);
13. } finally {
14. afterExecute(task, thrown); //运行完成，进行后续处理
15. }
16. } finally {
17. task = null;
18. w.completedTasks++;
19. w.unlock();
20. }
21. //省略无关部分
可以看到，程序会捕获包括Error在内的所有异常，并且在程序最后，将出现过的异常和当前任务传递给afterExecute方法。
而ThreadPoolExecutor中的afterExecute方法是没有任何实现的：
1. protected void afterExecute(Runnable r, Throwable t) { }
也就是说，默认情况下，线程池会捕获任务抛出的所有异常，但是不做任何处理。
存在问题
想象下ThreadPoolExecutor这种处理方式会有什么问题？
这样做能够保证我们提交的任务抛出了异常不会影响其他任务的执行，同时也不会对用来执行该任务的线程产生任何影响。
问题就在afterExecute方法上，这个方法没有做任何处理，所以如果我们的任务抛出了异常，我们也无法立刻感知到。即使感知到了，也无法查看异常信息。
所以，作为一名好的开发者，是不应该允许这种情况出现的。
如何避免这种问题
思路很简单。
1. 在提交的任务中将异常捕获并处理，不抛给线程池。
2. 异常抛给线程池，但是我们要及时处理抛出的异常。
第一种思路很简单，就是我们提交任务的时候，将所有可能的异常都Catch住，并且自己处理，任务的大致代码如下：
1. @Override
2. public void run() {
3. try {
4. //处理所有的业务逻辑
5. } catch (Throwable e) {
6. //打印日志等
7. } finally {
8. //其他处理
9. }
10. }
说白了就是把业务逻辑都trycatch起来。
但是这种思路的缺点就是：1）所有的不同任务类型都要trycatch，增加了代码量。2）不存在checkedexception的地方也需要都trycatch起来，代码丑陋。
第二种思路就可以避免上面的两个问题。
第二种思路又有以下几种实现方式：
1. 自定义线程池，继承ThreadPoolExecutor并复写其afterExecute(Runnable r, Throwable t)方法。
2. 实现Thread.UncaughtExceptionHandler接口，实现void uncaughtException(Thread t, Throwable e);方法，并将该handler传递给线程池的ThreadFactory
3. 采用Future模式，将返回结果以及异常放到Future中，在Future中处理
4. 继承ThreadGroup，覆盖其uncaughtException方法。（与第二种方式类似，因为ThreadGroup类本身就实现了Thread.UncaughtExceptionHandler接口)
下面是以上几种方式的代码
方式1
自定义线程池：
1. final class PoolService {
2. // The values have been hard-coded for brevity
3. ExecutorService pool = new CustomThreadPoolExecutor(
4. 10, 10, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
5. // ...
6. }
7. 8. class CustomThreadPoolExecutor extends ThreadPoolExecutor {
9. // ... Constructor ...
10. public CustomThreadPoolExecutor(
11. int corePoolSize, int maximumPoolSize, long keepAliveTime,
12. TimeUnit unit, BlockingQueue<Runnable> workQueue) {
13. super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
14. }
15. 16. 17. @Override
18. public void afterExecute(Runnable r, Throwable t) {
19. super.afterExecute(r, t);
20. if (t != null) {
21. // Exception occurred, forward to handler
22. }
23. // ... Perform task-specific cleanup actions
24. }
25. 26. @Override
27. public void terminated() {
28. super.terminated();
29. // ... Perform final clean-up actions
30. }
31. }
方式2
void uncaughtException(Thread t, Throwable e);方法，并将该handler传递给线程池的ThreadFactory
1. final class PoolService {
2. private static final ThreadFactory factory =
3. new ExceptionThreadFactory(new MyExceptionHandler());
4. private static final ExecutorService pool =
5. Executors.newFixedThreadPool(10, factory);
6. 7. public void doSomething() {
8. pool.execute(new Task()); // Task is a runnable class
9. }
10. 11. public static class ExceptionThreadFactory implements ThreadFactory {
12. private static final ThreadFactory defaultFactory =
13. Executors.defaultThreadFactory();
14. private final Thread.UncaughtExceptionHandler handler;
15. 16. public ExceptionThreadFactory(
17. Thread.UncaughtExceptionHandler handler)
18. {
19. this.handler = handler;
20. }
21. 22. @Override public Thread newThread(Runnable run) {
23. Thread thread = defaultFactory.newThread(run);
24. thread.setUncaughtExceptionHandler(handler);
25. return thread;
26. }
27. }
28. 29. public static class MyExceptionHandler extends ExceptionReporter
30. implements Thread.UncaughtExceptionHandler {
31. // ...
32. 33. @Override public void uncaughtException(Thread thread, Throwable t) {
34. // Recovery or logging code
35. }
36. }
37. }
方式3
继承ThreadGroup，覆盖其uncaughtException方法
1. public class ThreadGroupExample {
2. 3. public static class MyThreadGroup extends ThreadGroup {
4. 5. public MyThreadGroup(String s) {
6. super(s);
7. }
8. 9. public void uncaughtException(Thread thread, Throwable throwable) {
10. System.out.println("Thread " + thread.getName()
11. + " died, exception was: ");
12. throwable.printStackTrace();
13. }
14. }
15. 16. public static ThreadGroup workerThreads =
17. new MyThreadGroup("Worker Threads");
18. 19. public static class WorkerThread extends Thread {
20. public WorkerThread(String s) {
21. super(workerThreads, s);
22. }
23. 24. public void run() {
25. throw new RuntimeException();
26. }
27. 28. }
29. 30. public static void main(String[] args) {
31. Thread t = new WorkerThread("Worker Thread");
32. t.start();
33. }
34. }
确实这种方式与上面通过ThreadFactory来指定UncaughtExceptionHandler是一样的，只是代码逻辑不同，但原理上都是一样的，即给线程池中的每个线程都指定一个UncaughtExceptionHandler。
** 注意：上面三种方式针对的都是通过execute(xx)的方式提交任务，如果你提交任务用的是submit()方法，那么上面的三种方式都将不起作用,而应该使用下面的方式 **
方式4
如果提交任务的时候使用的方法是submit，那么该方法将返回一个Future对象，所有的异常以及处理结果都可以通过future对象获取。
采用Future模式，将返回结果以及异常放到Future中，在Future中处理
1. final class PoolService {
2. private final ExecutorService pool = Executors.newFixedThreadPool(10);
3. 4. public void doSomething() {
5. Future<?> future = pool.submit(new Task());
6. 7. // ...
8. 9. try {
10. future.get();
11. } catch (InterruptedException e) {
12. Thread.currentThread().interrupt(); // Reset interrupted status
13. } catch (ExecutionException e) {
14. Throwable exception = e.getCause();
15. // Forward to exception reporter
16. }
17. }
18. }
总结
- java线程池会捕获任务抛出的异常和错误，但不做任何处理
- 好的程序设计应该考虑到对于类异常的处理
- 处理线程池中的异常有两种思路：
1）提交到线程池中的任务自己捕获异常并处理，不抛给线程池
2）由线程池统一处理 - 对于execute方法提交的线程，有两种处理方式
1）自定义线程池并实现afterExecute方法
2）给线程池中的每个线程指定一个UncaughtExceptionHandler,由handler来统一处理异常。 - 对于submit方法提交的任务，异常处理是通过返回的Future对象进行的。
