java并发--捕获线程异常

由于线程的本质特性，使得不能捕获从线程中逃逸的异常。一旦异常逃出任务的main()方法，就会传播到控制台中，main方法中try-catch也是没有作用的。

这就使用到Thread.UncaughtExcuptionHandler接口，这个接口允许没个Thread对象附着一个异常处理器。

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

public class ExceptionDemo  {
    class myRunnalbe implements Runnable{

        @Override
        public void run() {
            System.out.println("thread:" + Thread.currentThread());
            throw new RuntimeException();// 抛出一个异常
        }
        
    }
    
    class myUncaughtExcuptionHandler implements Thread.UncaughtExceptionHandler {
        /**
         * 处理异常
         */
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            System.out.println("Exception::" + e);
        }
    }
    /**
     * 线程工厂
     * @author Administrator
     *
     */
    class myThreadFactory implements ThreadFactory {

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(new myUncaughtExcuptionHandler());// 设置一个异常处理器
            System.out.println("eh::" + t.getUncaughtExceptionHandler());
            return t;
        }
    }
    
    public static void main(String[] args) {
        ExceptionDemo demo = new ExceptionDemo();
        ExecutorService executor = Executors.newCachedThreadPool(demo.new myThreadFactory());
        executor.execute(demo.new myRunnalbe());
    }
}

这就是可以抓获异常。