线程池的异常处理

一、Java线程异常机制

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

public class Task 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 ThreadException {

    public static void main(String[] args) {

        Thread t1 = new Thread(new Task());
        //t1.setUncaughtExceptionHandler(new RuntimeExceptionHandle());

        t1.start();
        System.out.println("主线程执行结束！！！");
    }
}

运行结果：
主线程执行结束！！！
任务开始执行
Exception in thread “Thread-0” java.lang.ArithmeticException: / by zero
at com.ljj.threadException.Task.run(Task.java:30)
at java.lang.Thread.run(Thread.java:748)

t1线程运行抛出异常不会影响主线程的执行，当此类异常产生时，子线程就会终结。我们无法在主线程中捕获子线程抛出的异常进行处理，只能在run方法内部对业务逻辑进行try/catch。线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部。

如果不在run()内部捕获异常，该怎么处理呢？

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

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

public class RuntimeExceptionHandle implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        //打印异常信息到日志
        System.out.println("异常处理器调用, 打印日志: " + e);
    }
}

放开上述代码注释，执行结果：

主线程执行结束！！！
任务开始执行
异常处理器调用, 打印日志: java.lang.ArithmeticException: / by zero

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

原理分析：

从JDK1.5开始，当一个线程因未捕获的异常而即将终止时，JAVA虚拟机将使用Thread.getUncaughtExceptionHandler()查询该线程以获得其UncaughtExceptionHandler，并调用该handler的uncaughtException()方法，将线程和异常作为参数传递。如果没有，则搜索该线程的ThreadGroup的异常处理器。

ThreadGroup中的默认异常处理器实现是将处理工作逐层委托给上层的ThreadGroup，直到某个ThreadGroup的异常处理器能够处理该异常，否则一直传递到顶层的ThreadGroup。顶层ThreadGroup的异常处理器委托给默认的系统处理器（如果默认的处理器存在，默认情况下为空），否则把栈信息输出到System.err

二、线程池异常

线程池中的异常如果处理不好的话，经常会出现日志不打印，导致不能定位问题

public class ThreadPoolExecption {
    private static ExecutorService executor = Executors.newFixedThreadPool(3);

    public static void main(String[] args) {
        Task task = new Task();
        try {
            executor.execute(task);
            //executor.submit(task);
        } catch (Exception e) {
            System.out.println("捕获线程池的线程异常");
        }
    }
}

运行结果：

任务开始执行
Exception in thread “pool-1-thread-1” java.lang.ArithmeticException: / by zero
at com.ljj.threadException.Task.run(Task.java:30)
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)

虽然在控制台打印了异常堆栈信息，但是我们外层的catch并没有捕获这个运行时异常，在生产环境中，异常是不可能直接打印在控制台的，而是打印到对应的日志文件中去。

注意线程池执行有两个方法，如果使用submit方法的话，堆栈信息在控制台也不会打印。

分析线程池源码：

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. run方法里面try/catch所有处理逻辑

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

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

2. 自定义异常处理器

由于线程池传入的参数是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);
    }
}

执行结果：

任务开始执行
异常处理器调用, 打印日志: java.lang.ArithmeticException: / by zero

这种方法比较麻烦，更简单的是在Thread类中设置一个静态域，并将这个处理器设置为默认异常处理器

public class ThreadPoolExeception2 {
    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);
    }
}

注意上述方法只有在执行execute方法才可以捕获异常进行处理，submit方法是不起作用的，没有任何异常信息输出。

3. 重写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);
        }
    }
}

继承ThreadPoolExecutor 类并重写afterExecute()方法

public class ThreadPoolExeception4 {
    private static ThreadPoolExecutor executor = new MyThreadPool(1, 1, 0,
            TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());

    public static void main(String[] args) {
        Task task = new Task();
        executor.execute(task);
        //executor.submit(task);
        executor.shutdown();
    }
}

执行结果：

任务开始执行
Exception in thread “pool-1-thread-1” 打印异常日志：java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
at com.ljj.threadException.Task.run(Task.java:30)
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)

同样，这种方式submit方法是不适用的

4. 使用submit执行任务

public class ThreadPoolExeception3 {
    private static ExecutorService executor = Executors.newFixedThreadPool(3);

    public static void main(String[] args) {
        Task task = new Task();
        try {
            Future future = executor.submit(task);
            System.out.println(future.get());
        } catch (Exception e) {
            System.out.println("捕获线程池的线程异常：" + e);
        }
    }
}

执行结果：

任务开始执行
捕获线程池的线程异常：java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero

可以看到在使用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);
 }