线程捕捉异常
在Java中，线程中的异常是不能抛出到调用该线程的外部方法中捕获的。
因为线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部。”基于这样的设计理念，在Java中，线程方法的异常都应该在线程代码边界之内（run方法内）进行try catch并处理掉，换句话说，我们不能捕获从线程中逃逸的异常。
public static void main(String[] args){
try {
new Thread( () -> {
int i = 1/ 0;
}).start();
}catch (Exception e){
System.out.println(1);
}
}
可以看到，外部的catch并没有捕捉到。
Thread类的run()方法声明，方法声明上没有对抛出异常进行任何约束，也就是异常不会抛到外部。如果内部没有catch，那么Thread的默认异常处理就是调用 System.err 进行输出，也就是直接打印到控制台了。
解决方案
线程内部显式try…catch
public static void main(String[] args){
new Thread( () -> {
try {
int i = 1/ 0;
}catch (Exception e){
System.out.println("1");
}
}).start();
}
可以看到我们在线程内部显式的进行try/catch，异常被捕获。
给线程定义异常处理器
查看Thread类的源码，我们可以看到有个dispatchUncaughtException方法，此方法就是用来处理线程中抛出的异常的。JVM会调用dispatchUncaughtException方法来寻找异常处理器(UncaughtExceptionHandler)，处理异常。
/**
* Dispatch an uncaught exception to the handler. This method is
* intended to be called only by the JVM.
*/
private void dispatchUncaughtException(Throwable e) {
getUncaughtExceptionHandler().uncaughtException(this, e);
}
/**
* 获取用来处理未捕获异常的handler，如果没有设置则返回当前线程所属的ThreadGroup
*
**/
public UncaughtExceptionHandler getUncaughtExceptionHandler() {
return uncaughtExceptionHandler != null ?
uncaughtExceptionHandler : group;
}
uncaughtExceptionHandler 默认为null，null的话就调用线程所属group的默认handler
// 这里也就是打印到控制台
public void uncaughtException(Thread t, Throwable e) {
if (parent != null) {
parent.uncaughtException(t, e);
} else {
Thread.UncaughtExceptionHandler ueh =
Thread.getDefaultUncaughtExceptionHandler();
if (ueh != null) {
ueh.uncaughtException(t, e);
} else if (!(e instanceof ThreadDeath)) {
System.err.print("Exception in thread \""
+ t.getName() + "\" ");
e.printStackTrace(System.err);
}
}
}
所以我们可以通过设置Thread的uncaughtExceptionHandler 来设置异常处理器
public static void main(String[] args){
Thread thread = new Thread(() -> {
int i = 1 / 0;
});
thread.setUncaughtExceptionHandler((t, e) -> System.out.println("捕捉到异常"));
thread.start();
}
线程池自定义处理异常
在线程池，我们可以批量的为所有线程设置uncaughtExceptionHandler，线程是由ThreadFactory产生的，所以我们可以通过这里入手。
通过复写ThreadFactory的newThread就可实现。
public class ThreadExceptionDemo {
private static final int CORE_POOL_SIZE = 3;
private static final int MAX_POOL_SIZE = 100;
private static final int QUEUE_CAPACITY = 5;
private static final Long KEEP_ALIVE_TIME = 5L;
public static void main(String[] args){
// 在构造函数塞进去我们要的ThreadFactory
ThreadPoolExecutor executor = new ThreadPoolExecutor(
CORE_POOL_SIZE,
MAX_POOL_SIZE,
KEEP_ALIVE_TIME,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(QUEUE_CAPACITY),
new MyThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
executor.execute(()->{
int i = 1 / 0;
});
}
}
class MyThreadFactory implements ThreadFactory{
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r);
thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("捕捉到了");
}
});
return thread;
}
}
通过Future的get方法捕获异常
线程池的submit是带有返回值的
public static void main(String[] args){
ExecutorService executorService = Executors.newFixedThreadPool(2);
Future future = executorService.submit(()->{
int i = 1 / 0;
});
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
System.out.println("捕捉到了");
}
}
