ThreadPoolExecutor异常处理

java.util.concurrent包中的ThreadPoolExecutor，提供了java语言的线程池，你可以提交一个返回结果的任务（submit(Callable)，返回Future），或者执行一个不返回结果的任务（execute(Runnable)），但提交的任务可能会抛异常，这就需要处理异常：

1. 对于submit的任务，框架会将异常保持在future里，并包装在ExecutionException里，当调用Future.get()时，再次throw，这时可以调用ExecutionException.getCause()获取包装的exception，这种情况下，设置UncaughtExceptionHandler也不会被调用。

2. 对应execute的任务，会直接throw，可以设置一个UncaughtExceptionHandler，例如：

import java.lang.Thread.UncaughtExceptionHandler;
import java.util.Random;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ExecutorServiceDemo {

    public static void testExecute() {
        ExecutorService executors = new ThreadPoolExecutor(10, 20, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(), new ThreadFactory() {
                    final AtomicInteger threadNumber = new AtomicInteger(1);

                    public Thread newThread(Runnable r) {
                        Thread t = new Thread(Thread.currentThread().getThreadGroup(), r, "topPatternTasklet-thread"
                                + (threadNumber.getAndIncrement()));
                        t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {

                            public void uncaughtException(Thread t, Throwable e) {
                                System.out.println(e);
                            }

                        });
                        return t;
                    }
                }, new ThreadPoolExecutor.CallerRunsPolicy());

        final Random r = new Random();
        for (int i = 0; i < 10; ++i) {
            executors.execute(new Runnable() {

                public void run() {
                    try {
                        int ri = r.nextInt(1000);
                        Thread.sleep(ri);
                        if (ri % 3 == 0) {
                            System.out.println("ri:" + ri);
                            throw new RuntimeException("haha error!");
                        }
                        System.out.println(Thread.currentThread());
                    } catch (InterruptedException e) {
                    }
                }
            });
        }

        executors.shutdown();
        System.out.println("finished");
    }
    public static void main(String[] args) {
        testExecute();
    }
}