Java异常在线程之间不是共享的,在线程中抛出的异常是线程自己的异常,主线程并不能捕获到。也就是说你把线程执行的代码看成另一个主函数。
上面A和B的运行是互相独立的,虽然说你看到B所在代码块的函数内容在main中,但是main并不能捕获到这个Runnable里函数的异常,因为它不在同一个线程之中运行,B中抛出的异常如果你不在另一个线程捕获的话,相当于就是没有异常处理,无法捕获。
在java多线程程序中,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己将checked exception处理掉,run方法上面进行了约束,不可以抛出异常(throws Exception)
public class ThreadSample implements Runnable { @Override public void run() { //run()方法上不可以抛出异常 System.out.println("任务开始执行"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } int i = 10 /0; //这里抛出RuntimeException() System.out.println("任务执行结束"); } } public class ThreadErrorTest { public static void main(String[] args) { Thread a = new Thread(new ThreadSample()); a.start(); System.out.println("主线程执行结束!!!"); } }
a线程运行抛出异常不会影响主线程的执行,当此类异常产生时,子线程就会终结。
所以,无法在主线程中捕获子线程抛出的异常进行处理,只能在run方法内部对业务逻辑进行try/catch。
线程是独立执行的代码片断,线程的问题应该由线程自己来解决,而无法委托到外部。
Thread中Java提供了一个setUncaughtExceptionHandler的方法来设置线程的异常处理函数,你可以把异常处理函数传进去,当发生线程的未捕获异常的时候,由JVM来回调执行。
可以使用Thread.UncaughtExceptionHandler为每个线程设置异常处理器,Thread.UncaughtExceptionHandler.uncaughtException()方法会在线程因未捕获的异常而面临死亡时被调用,上述子线程本身因为异常终止打印到控制台也是由于UncaughtExceptionHandler
实现UncaughtExceptionHandler接口并重写uncaughtException方法,在uncaughtException方法中打印日志即可:
public class ThreadErrorTest { public static void main(String[] args) { Thread a = new Thread(new ThreadSample()); a.setUncaughtExceptionHandler(new RuntimeExceptionHandle()); a.start(); System.out.println("主线程执行结束!!!"); } } public class RuntimeExceptionHandle implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { //打印异常信息到日志 System.out.println("异常处理器调用, 打印日志: " + e); } }
子线程在抛出运行时异常,调用自定义的异常处理器,进行异常处理(日志打印)
当一个线程因未捕获的异常而即将终止时,JAVA虚拟机将使用Thread.getUncaughtExceptionHandler()查询该线程以获得其UncaughtExceptionHandler
调用该handler的uncaughtException()方法,将线程和异常作为参数传递。
如果没有,则搜索该线程的ThreadGroup的异常处理器。
ThreadGroup中的默认异常处理器实现是将处理工作逐层委托给上层的ThreadGroup,直到某个ThreadGroup的异常处理器能够处理该异常,否则一直传递到顶层的ThreadGroup。
顶层ThreadGroup的异常处理器委托给默认的系统处理器(如果默认的处理器存在,默认情况下为空),否则把栈信息输出到System.err
public void run() { try { //处理逻辑 } catch(Exeception e) { //打印日志 } }
这是一种简单而且不易出错的线程池异常处理方式,推荐使用。
线程池的线程在执行结束前肯定调用afterExecute方法,所有只需要重写该方法即可。
public class MyThreadPool extends ThreadPoolExecutor { public MyThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); } @Override public void afterExecute(Runnable r, Throwable t) { if(t != null) { System.out.println("打印异常日志:" + t); } } }
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } else if (!addWorker(command, false)) reject(command); } /** * addWorker方法部分内容 */ w = new Worker(firstTask); //封装成Worker对象 final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); workers.add(w); int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { t.start(); workerStarted = true; } /** * worker对象里面的run方法部分内容 */ while (task != null || (task = getTask()) != null) { w.lock(); if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { beforeExecute(wt, task); Throwable thrown = null; try { task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { afterExecute(task, thrown); //执行改方法 } } finally { task = null; w.completedTasks++; w.unlock(); } }
首先ThreadPoolExecutor中execute方法会将传入的task封装成Worker对象,在进入Worker对象的run方法,发现异常被线程池捕获了。
但是最后在finally会执行 afterExecute(task, thrown)方法,该方法的方法体是空,里面没有任何逻辑。
我们知道在使用submit执行任务,该方法将返回一个Future对象,不仅仅是任务的执行结果,异常也会被封装到Future对象中,通过get()方法获取。
public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); //封装成FutureTask对象交给execute方法 return ftask; }
由于调用ThreadPoolExecutor的execute方法,会被封装成Worker对象,然后调用FutureTask对象的run方法:
public void run() { if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) return; try { Callable<V> c = callable; if (c != null && state == NEW) { V result; boolean ran; try { result = c.call(); ran = true; } catch (Throwable ex) { result = null; ran = false; setException(ex); //捕获异常 } if (ran) set(result); } } finally{ ...... }
捕获异常后调用setException(ex)方法,setExcetion首先是将一个异常信息赋值给一个全局变量outcome,并且将全局的任务状态state字段通过CAS更新为3(异常状态)然后最后做一些清理工作。
FutureTask.get()方法中,会对setException方法中设置的outcome和state做一些逻辑判断,然后直接往上抛出了异常,所以我们就可以在主线程中捕获这个异常。
public V get() throws InterruptedException, ExecutionException { int s = state; if (s <= COMPLETING) s = awaitDone(false, 0L); return report(s); } private V report(int s) throws ExecutionException { Object x = outcome; if (s == NORMAL) return (V)x; if (s >= CANCELLED) throw new CancellationException(); throw new ExecutionException((Throwable)x); }
由于线程池传入的参数是Runnable不是Thread,执行一个个对应的任务,所以这里我们需要使用ThreadFactory创建线程池
public class MyThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { Thread t = new Thread(r); t.setUncaughtExceptionHandler(new RuntimeExceptionHandle()); return t; } }
继承ThreadFactory,并重写newThread(Runnable r)方法设置异常处理器,在异常处理器中捕获并处理异常(打印日志)
public class ThreadPoolExecption1 { private static ExecutorService executor = Executors.newSingleThreadExecutor(new MyThreadFactory()); public static void main(String[] args) { Task task = new Task(); executor.execute(task); executor.submit(task); } }
这种方法比较麻烦,更简单的是在Thread类中设置一个静态域,并将这个处理器设置为默认异常处理器,但是,这个属于全局化的,慎用!如果需要定制化,还需要专门定制。
public class ThreadPoolException2 { private static ExecutorService executor = Executors.newFixedThreadPool(3); public static void main(String[] args) { Thread.setDefaultUncaughtExceptionHandler(new RuntimeExceptionHandle()); Task task = new Task(); executor.execute(task); //executor.submit(task); } }