java线程捕获异常

java多线程程序中，所有线程都不允许抛出未捕获的checked exception（比如sleep时的InterruptedException），也就是说各个线程需要自己把自己的checked exception处理掉。这一点是通过java.lang.Runnable.run()方法声明(因为此方法声明上没有throw exception部分)进行了约束。但是线程依然有可能抛出unchecked exception（如运行时异常），当此类异常跑抛出时，线程就会终结，而对于主线程和其他线程完全不受影响，且完全感知不到某个线程抛出的异常(也是说完全无法catch到这个异常)。JVM的这种设计源自于这样一种理念：“线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部。”基于这样的设计理念，在Java中，线程方法的异常（无论是checked还是unchecked exception），都应该在线程代码边界之内（run方法内）进行try catch并处理掉.换句话说，我们不能捕获从线程中逃逸的异常。下面是一个在run方法中定义了一个运行时的异常

public class ExceptionThread2 implements Runnable {

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        System.out.println("run() By" + t);
        System.out.println("eh = " + t.getUncaughtExceptionHandler());
        throw new RuntimeException();
    }

}

如果我们用常用的try catch 去捕捉异常

package test.threadE;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExceptionThread implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException();
    }

    public static void main(String[] args) {
        try {

            ExecutorService exc = Executors.newCachedThreadPool();
            exc.execute(new ExceptionThread());
            System.out.println("主线程是可以执行到这的 只是出错的子线程被干掉了");
        } catch (Exception e) {
            System.err.println("捕获到异常了");
        }
    }

}

控制台输出的结果 是捕捉不到错误的

Exception in thread "pool-1-thread-1" 主线程是可以执行到这的 只是出错的子线程被干掉了
java.lang.RuntimeException
    at test.threadE.ExceptionThread.run(ExceptionThread.java:10)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    at java.lang.Thread.run(Unknown Source)

其实jdk5之前的解决办法是线程组，在jdk5之后 新引进了一个接口 Thread.UncaughtExceptionHandler 这个接口的作用就是为每个创建的线程都附着一个异常处理器，然后我们为了

使用到这个组件去创建线程，又引进了一个新的对象 ThreadFactory对象，这个也是一个接口，我们重写的方法newThread 就是它返回新线程的方法，在这个方法中为每个新创建的线程都设置 上面的Thread.UncaughtExceptionHandler，然后将带有异常处理器的线程返回看下面的代码

第一步：创建Thread.UncaughtExceprionhandler的实例

class MyUncaughtExceptionhandler implements Thread.UncaughtExceptionHandler {

    /**
     * 捕获异常 线程当中出现的异常 将在这里捕获
     */
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("caught  " + e);
    }

第二步：创建ThreadFactory

class HandelThreadFactory implements ThreadFactory{
   /**
    * 这是返回Thread   然后方法中是为每个线程设置UncaughtExceptionHandler 也就是上面的Thread.UncaughtExceptionHandler 
    */
    @Override
    public Thread newThread(Runnable r) {
        System.out.println(this+" creating new Thread");
        Thread t = new Thread(r);
        System.out.println("created " + t);
        t.setUncaughtExceptionHandler(new MyUncaughtExceptionhandler());
        System.out.println("eh = "+ t.getUncaughtExceptionHandler());
        return t;
    } 

然后我们测试一下

public class CaptureUncaughtException {

    public static void main(String[] args) {
        /**
         * 创建线程池的时候 把Threadfactory的实现类做参数传进来 。创建出的线程
         * 每条的都会附着一个Thread.UncaughtExceptionhandler
         */
        ExecutorService exc = Executors.newCachedThreadPool(new HandelThreadFactory());
        exc.execute(new ExceptionThread());
　　　　 exc.shutdown();
    
    }

}看下控制台输出的结果

test.threadE.HandelThreadFactory@5c647e05 creating new Thread
created Thread[Thread-0,5,main]
eh = test.threadE.MyUncaughtExceptionhandler@33909752
caught  java.lang.RuntimeException

这样就实现了 不会由于检查不到的运行时错误 导致线程意外死亡，我们也可以捕捉到这个运行时错误，方便我们统一管理 并且如果线程中需要释放资源的时候 我们可以写在 Thread.UncaughtExceptionHandler 实现类当中的UncaughtExceptionHandler方法中，这样线程就实现了 单独的执行的代码片段 自己出现的问题依靠自己解决，而不会跑该线程的外面。