爱站程序员基地线程异常捕获问题
Java异常在线程之间不是共享的，在线程中抛出的异常是线程自己的异常，主线程并不能捕获到。也就是说你把线程执行的代码看成另一个主函数。
上面A和B的运行是互相独立的，虽然说你看到B所在代码块的函数内容在main中，但是main并不能捕获到这个Runnable里函数的异常，因为它不在同一个线程之中运行，B中抛出的异常如果你不在另一个线程捕获的话，相当于就是没有异常处理，无法捕获。
在java多线程程序中，所有线程都不允许抛出未捕获的checked exception，也就是说各个线程需要自己将checked exception处理掉，run方法上面进行了约束，不可以抛出异常(throws Exception)
public class ThreadSample implements Runnable {@Overridepublic 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 {@Overridepublic void uncaughtException(Thread t, Throwable e) {//打印异常信息到日志System.out.println("异常处理器调用, 打印日志: " + e);}}
子线程在抛出运行时异常，调用自定义的异常处理器，进行异常处理（日志打印）
原理分析
-
当一个线程因未捕获的异常而即将终止时，JAVA虚拟机将使用Thread.getUncaughtExceptionHandler()查询该线程以获得其UncaughtExceptionHandler
-
调用该handler的uncaughtException()方法，将线程和异常作为参数传递。
-
如果没有，则搜索该线程的ThreadGroup的异常处理器。
-
ThreadGroup中的默认异常处理器实现是将处理工作逐层委托给上层的ThreadGroup，直到某个ThreadGroup的异常处理器能够处理该异常，否则一直传递到顶层的ThreadGroup。
-
顶层ThreadGroup的异常处理器委托给默认的系统处理器（如果默认的处理器存在，默认情况下为空），否则把栈信息输出到System.err
线程池的异常捕获方式？
下面给线程池对于不可捕捉异常也提供了多种方式去处理:
- run方法里面try/catch所有处理逻辑
public void run() {try {//处理逻辑} catch(Exeception e) {//打印日志}}
这是一种简单而且不易出错的线程池异常处理方式，推荐使用。
- 重写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);}@Overridepublic 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 startablethrow 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)方法，该方法的方法体是空，里面没有任何逻辑。
- 使用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 {@Overridepublic 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);}}
