UncaughtExceptionHandler—处理Runnable线程内的非受检异常

秒速五厘米 2021-06-22 15:38 418阅读 0赞

Java入门的多线程方案就是Thread类和Runnable接口。如下：

public class Demo {
        public static void main(String[] args) {
            fun1();
            fun2();
        }
     
        public static void fun1() {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    System.out.println("fun1-thread");
                }
            };
            thread.start();
        }
     
        public static void fun2() {
            new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("fun2-thread");
    			}
            }).start();
        }
    }

今天我们要说的是线程内部的异常处理。Java的异常(包括Exception和Error)分为检查异常（checked exceptions）和非检查的异常（unchecked exceptions），很好理解：

*  检查异常：编译器要求必须处理的异常，代码在运行前，编译器要求你必须要对这段代码try...catch，或者throws exception，这类这就是检查异常。
 *  非检查异常：只有在运行期才能检查出来的异常，比如NullpointException...

由于在多线程中，run()方法无法继续向上显式抛出异常，所以在线程内部的异常我们必须处理，否则异常会被JVM捕获到，这时JVM就会将线程杀掉。线程内部该如何处理异常呢？

*  对于受检异常：就是直接在run()方法体中try-catch异常，然后进行对应的处理；
 *  对于非受检异常：虽然编译期不做检查，但仍然可以使用try-catch处理；如果没有try-catch，JVM会帮助我们捕获到异常。

new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("thread start...");
    				try {
    					int a = 1/0;//uncheck exception
    				} catch (Exception e) {
    					System.out.println("uncheck exception...");
    				}
                    try {
    					Thread.sleep(10000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
                    System.out.println("after sleep 10 ms,thread end...");
    			}
            }).start();
    //输出：
    thread start...
    uncheck exception...
    after sleep 10 ms,thread end...

上面代码int a = 1/0 是运行期异常，如果用try-catch处理，后面的代码还可以执行，否则抛出异常被JVM捕获，后面的sleep代码就无法执行到。

我们的代码中不可能对所有的运行时异常（unchecked exception）做处理，所以线程中如果未处理的unchecked exception被抛出，那么我们如何处理JVM捕获的异常呢？答案是Thread.UncaughtExceptionHandler类。正如JDK文档所介绍的一样：

“当一个线程由于发生了非受检异常而终止时，JVM会使用Thread.gerUncaughtExceptionHandler()方法查看该线程上的UncaughtExceptionHandler，并调用他的uncaughtException()方法”。

下面我们来尝试使用hread.UncaughtExceptionHandler类，来处理线程内部的非受检异常（受检异常直接在run()方法体内部的catch子句中处理）。

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
     
    
    public class Demo {
     
        public static void main(String[] args) throws InterruptedException {
            new Thread(new Runnable() {
    			@Override
    			public void run() {
    				//设置非受检异常的ExceptionHandler
    				Thread.currentThread().setUncaughtExceptionHandler(new ThreadExceptionHandler());
    				System.out.println("thread start...");
    				int a = 1/0;//unchecked exception
                    try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
                    System.out.println("after sleep 10 ms,thread end...");
    			}
            }).start();
        }
     
        private static final class ThreadExceptionHandler implements Thread.UncaughtExceptionHandler {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("One uncaught exception was got:");
                System.out.println("Thread id=" + t.getId());
                System.out.println("Thread name=" + t.getName());
                e.printStackTrace(System.out);
            }
        }
    }
    //输出
    thread start...
    One uncaught exception was got:
    Thread id=10
    Thread name=Thread-0
    java.lang.ArithmeticException: / by zero
    	at com.iqiyi.toutiao.Test.ThreadTest$2.run(ThreadTest.java:92)
    	at java.lang.Thread.run(Thread.java:748)

在线程代码中如果是受检异常，直接在run()方法体中处理；对于非受检异常，我们在run()方法体的开头设置了非受检异常处理类ThreadExceptionException，这个类的uncaughtException()方法就是处理线程内部非捕获异常的具体执行者。（读者要清楚，一旦一个线程抛出了非受检异常，JVM就会把它杀死，然后把捕获到的非受检异常传递给UncaughtExceptionHandler类对象类处理）。

一定有读者会问，如果没有通过setUncaughtExceptionHandler()方法设置Handler怎么办？这个问题在JDK API中给了回答：  
“如果一个线程没有显式的设置它的UncaughtExceptionHandler，JVM就会检查该线程所在的线程组是否设置了UncaughtExceptionHandler，如果已经设置，就是用该UncaughtExceptionHandler；否则查看是否在Thread层面通过静态方法setDefaultUncaughtExceptionHandler()设置了UncaughtExceptionHandler，如果已经设置就是用该UncaughtExceptionHandler；如果上述都没有找到，JVM会在对应的console中打印异常的堆栈信息。”

/**
     * Created by yizhen on 2017/1/7.
     */
    public class Demo {
     
        public static void main(String[] args) throws InterruptedException {
            Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                @Override
                public void uncaughtException(Thread t, Throwable e) {
                    System.out.println("static thread exception handler -- " + t.getName());
                }
            });
            final Thread t1 = new Thread(new ThreadTaskWithHandler(), "t1");
            t1.start();
     
            final Thread t2 = new Thread(new ThreadTaskNoHandler(), "t2");
            t2.start();
     
        }
     
        private static final class ThreadExceptionHandler implements Thread.UncaughtExceptionHandler {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("explicit exception handler -- " + t.getName());
            }
        }
     
        private static final class ThreadTaskWithHandler implements Runnable {
     
            @Override
            public void run() {
                Thread.currentThread().setUncaughtExceptionHandler(new ThreadExceptionHandler());
                System.out.println(12 / 0);
            }
        }
     
        private static final class ThreadTaskNoHandler implements Runnable {
            @Override
            public void run() {
                System.out.println(12 / 0);
            }
        }
    }

从上面的程序可以看到，t1线程的非受检异常始终会被explicit exception handler捕获到，而t2线程的非受检异常始终会被static thread exception handler捕获到。  
至此，Thread线程内的异常处理就介绍完了，这包括受检异常和非受检异常。细心的读者会发现，本文仅仅涉及Thread和Runnable的多线程体系。在Java中，还有Executor和Callable的多线程体系。那关于这个体系的异常如何处理呢？笔者会后续博文中介绍！