捕获异常(线程)学习笔记

由于线程的本质，使得你不能捕获从线程中逃逸出来的异常。一旦异常逃出任务的run()方法，它就会向外传播到控制台，除非采取特殊的步骤捕获这种错误的异常。在java SE5之前，可以用线程组捕获异常，但是有了java SE5，就可以用Executor来解决这个问题。

class ExceptionThread implements Runnable{
	public void run() {
		throw new RuntimeException();
	}
}
public class NaiveExceptionHandling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
            ExecutorService exec=Executors.newCachedThreadPool();
            exec.execute(new ExceptionThread());
		}catch(RuntimeException e) {
			System.out.println("Exception has been handled");
		}
	}

}
/*
Exception in thread "pool-1-thread-1" java.lang.RuntimeException
at demo.ExceptionThread.run(NaiveExceptionHandling.java:8)
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)
*/

由以上程序运行后在窗口可见并没有打印"Exception has been handled"，因此在线程中抛出的异常放到try-catch子句中是捕获不了的。

为了解决这个问题，我们要修改Executor产生线程的方式。
Thread.UncaughtExceptionHandler是java SE5中的新接口，它允许你在每个Thread对象都附着上一个异常处理器。Thread.UncaughtExceptionHandler.uncaughtException()会在线程因未捕获的异常而临近死亡时被调用。

class ExceptionThread2 implements Runnable{
	public void run() {
		Thread t=Thread.currentThread();
		System.out.println("run() by "+t);
		System.out.println("ek = "+t.getUncaughtExceptionHandler());
		throw new RuntimeException();
	}
}
class MyUncaughtExceptionHandler implements UncaughtExceptionHandler{

	@Override
	public void uncaughtException(Thread t, Throwable e) {
		// TODO Auto-generated method stub
		System.out.println("caught "+e);
	}
	
}
class HandlerThreadFactory implements ThreadFactory{

	@Override
	public Thread newThread(Runnable r) {
		// TODO Auto-generated method stub
		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) {
		// TODO Auto-generated method stub
        ExecutorService exec=Executors.newCachedThreadPool(new HandlerThreadFactory());
        exec.execute(new ExceptionThread2());
	}

}
/*
demo.HandlerThreadFactory@4e25154f creating new Thread
created Thread[Thread-0,5,main]
eh = demo.MyUncaughtExceptionHandler@70dea4e
run() by Thread[Thread-0,5,main]
ek = demo.MyUncaughtExceptionHandler@70dea4e
demo.HandlerThreadFactory@4e25154f creating new Thread
created Thread[Thread-1,5,main]
eh = demo.MyUncaughtExceptionHandler@3670f81
caught java.lang.RuntimeException
*/

以上程序创建了一个新类型的ThreadFactory(通过编写定制的ThreadFactory可以定制由Excecutor创建的线程的属性(后台、优先级、名称)。)，它将在每个新创建的Thread对象上附着一个Thread.UncaughtExceptionHandler。我们将这个工厂传递给Executors创建新的ExecutorService的方法。

如果将要在代码中处处使用相同的异常处理器，那么更简单的方式是在Thread类中设置一个静态域，并将这个处理器设置成默认的为捕获异常处理器。
Thread.setDeflautUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
这个处理器只有在不存在线程的专有的未捕获异常的处理器的情况下才会被调用。即最后才调用以上方法。