线程池之异常处理

关键接口

UncaughtExceptionHandler : 自定义异常处理

    //自定义异常处理器类，并实现接口 UncaughtExceptionHandler
    public static class ExceptionHandler implements Thread.UncaughtExceptionHandler
    {
        @Override
        public void uncaughtException(Thread t, Throwable e)
        {
            System.out.println("---------------------------------");
            System.out.println(t.getName() + ":" + e.getMessage());
        }
    }

ThreadFactory : 线程池工厂,设置自定义异常处理器类

    //自定义线程池工厂
    public static class MyThreadFactory implements ThreadFactory {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(new ExceptionHandler());
            System.out.println("Thread[" + t.getName() + "] created.");
            return t;
        }
    }

注:execute不能和callable结合使用;

runnable不能返回结果,callable可以返回结果;

submit和runnable结合使用不能返回结果(但是可以返回异常),submit和callable结合使用可以在future中get到结果

情景一 : execute和Runnable结合使用(不能返回结果,可以返回异常)

        ExecutorService executorService = Executors.newCachedThreadPool(new MyThreadFactory());
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                int i = 1/0;
            }
        });
        executorService.shutdownNow();

运行结果:

Thread[Thread-0] created.
---------------------------------
Thread-0:/ by zero

自定义异常处理生效,可以在自定义处理器中处理异常

情景二 : submit和Runnable结合使用(不能返回结果,future.get中获取异常)

        Future<?> future = executorService.submit(new Runnable() {
            @Override
            public void run() {
                int i = 1 / 0;
                System.out.println("111");
            }
        });
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdownNow();

运行结果

Thread[Thread-0] created.
java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.util.concurrent.FutureTask.get(FutureTask.java:192)
	at com.mashibing.ConcurrentHashMap.test6.main(test6.java:23)
Caused by: java.lang.ArithmeticException: / by zero
	at com.mashibing.ConcurrentHashMap.test6$1.run(test6.java:18)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	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)

Process finished with exit code 0

异常会被future返回,自定义异常处理不生效,可以在catch中处理异常

情景三 : submit和Callable结合使用(可以返回结果,future.get中获取异常)

        ExecutorService executorService = Executors.newCachedThreadPool(new MyThreadFactory());

        Future<Integer> future = executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int i = 1 / 0;
                return 1;
            }
        });
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdownNow();

运行结果:

Thread[Thread-0] created.
java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.util.concurrent.FutureTask.get(FutureTask.java:192)
	at com.mashibing.ConcurrentHashMap.test6.main(test6.java:38)
Caused by: java.lang.ArithmeticException: / by zero
	at com.mashibing.ConcurrentHashMap.test6$1.call(test6.java:33)
	at com.mashibing.ConcurrentHashMap.test6$1.call(test6.java:30)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	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)

异常会被future返回,自定义异常处理不生效,可以在catch中处理异常

结论:

如果是execute提交任务可以自定义异常类处理异常;

如果是submit提交任务可以try-catch future.get处理异常;

整体代码:

import java.util.concurrent.*;

public class ThreadPoolExceptionTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool(new MyThreadFactory());
/*        executorService.execute(new Runnable() {
            @Override
            public void run() {
                int i = 1/0;
            }
        });*/
        /*--------------------------*/
/*        Future<?> future = executorService.submit(new Runnable() {
            @Override
            public void run() {
                int i = 1 / 0;
                System.out.println("111");
            }
        });
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }*/
        /*--------------------------*/
        Future<Integer> future = executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int i = 1 / 0;
                return 1;
            }
        });
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        /*--------------------------*/
        executorService.shutdownNow();
    }

    //自定义异常处理器类，并实现接口 UncaughtExceptionHandler
    public static class ExceptionHandler implements Thread.UncaughtExceptionHandler
    {
        @Override
        public void uncaughtException(Thread t, Throwable e)
        {
            System.out.println("---------------------------------");
            System.out.println(t.getName() + ":" + e.getMessage());
        }
    }
    //自定义线程池工厂
    public static class MyThreadFactory implements ThreadFactory {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(new ExceptionHandler());
            System.out.println("Thread[" + t.getName() + "] created.");
            return t;
        }
    }
}