新建线程的异常处理

将Thinking injava 12.2.14节进行总结

一般情况：

由于线程的本质特性，使你不能捕获从线程中逃逸的异常。一旦异常逃出任务的run方法，它就会向外传播到控制台

package hfi.bellychang.Task.CaptureException.Demo01;import org.junit.Test;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * 子线程中的异常在主线程中是捕捉不到的 * Created by Administrator on 2017/6/26. */class ExceptionThread implements Runnable {    Logger logger = LoggerFactory.getLogger(ExceptionThread.class);    ExceptionThread(){        super();        logger.info("exception happens in ExceptionThread");    }    @Override    public void run() {        throw new RuntimeException();    }}public class MainThread {    @Test    public void test() {        ExecutorService exec = Executors.newCachedThreadPool();        exec.execute(new ExceptionThread());    }}

运行结果：异常向外传播到控制台

问题自然来了，如何捕捉子线程中的异常，使其不直接向外传播到控制台呢？

解决方案1：

实现ThreadFactory接口，在newThread方法中附加异常处理器。将这个工厂传递给Executors创建新的ExecutorService的方法，就设置了这个线程池专有的未捕获异常的处理器

package hfi.bellychang.Task.CaptureException.Demo02;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ThreadFactory;/** * 在主线程中捕获子线程产生的异常 * 要修改Executor产生钱程的方式 * Thread.UncaughtExceptionHandler是Java SE5 中的新接口， * 它允许你在每个Thread对象上都附着一个异常处理器o * Thread.UncaughtExceptionHandler。uncaughtException()会在线程因未捕获的异常而临近死亡时被调用 * * Created by Administrator on 2017/6/26. */class ExceptionThread2 implements Runnable {    public void run() {        throw new RuntimeException();    }}class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {    Logger logger = LoggerFactory.getLogger(MyUncaughtExceptionHandler.class);    @Override    public void uncaughtException(Thread t, Throwable e) {        logger.info("caught " + e);    }}/** * 创建了一个新类型的ThreadFactory, 它将在每个新创建的Thread对象上 * 附着一个Thread.UncaughtExceptionHandler */class HandlerThreadFactory implements ThreadFactory {    Logger logger = LoggerFactory.getLogger(this.getClass());    @Override    public Thread newThread(Runnable r) {        Thread t = new Thread(r);        logger.info("created " + t);        //附着一个Thread.UncaughtExceptionHandler        t.setUncaughtExceptionHandler(                new MyUncaughtExceptionHandler());        return t;    }}/** * 示例使得你可以按照具体情况逐个地设置处理器 * 意思是通过不同的ThreadFactory的实现 附着不同的ExceptionHandler? */public class MainThread {    public static void main(String[] args) {        //我们将这个工厂传递给Executors创建新的ExecutorService的方法：        //此线程池专有的未捕获异常处理器        ExecutorService exec = Executors.newCachedThreadPool(                new HandlerThreadFactory());        exec.execute(new ExceptionThread2());    }}

执行结果

可见通过不同的ThreadFactory的实现，附着不同的ExceptionHandler，可以按照具体情况逐个地设置处理器

解决方案2：

在Thread类中设置一个静态域，并将这个处理器设置为Thread类的默认的未捕获异常处理器 Thread.setDefaultUncaughtExceptionHandler，但这样不能指定某个Thread使用哪个异常处理器

package hfi.bellychang.Task.CaptureException.Demo03;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * 通过这种方式，在主线程中捕获到了子线程中的异常 * Created by Administrator on 2017/6/26. */class ExceptionThread implements Runnable {    public void run() {        throw new RuntimeException();    }}class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {    Logger logger = LoggerFactory.getLogger(this.getClass());    @Override    public void uncaughtException(Thread t, Throwable e) {        logger.info("caught " + e);    }}public class MainThread {    public static void main(String[] args) {        Thread.setDefaultUncaughtExceptionHandler(                new MyUncaughtExceptionHandler());        ExecutorService exec = Executors.newCachedThreadPool();        exec.execute(new ExceptionThread());    }}

通过以上的两种方式，就可以将异常信息在catch中写入日志文件，在日志文件中查看子线程是否发生异常，对程序的运行情况有所掌握