ThreadPoolExecutor(七)——总结&补充

1.关于异常

线程池在执行execute方法和submit任务的时候，如果任务中抛出了异常，外部线程无法感知，所以要做一些措施来进行处理，下面就说一下产生这种效果的原因以及一些可用的处理方法。

关于异常的处理内容参考了文章并进行了相关补充： ExecutorService-10个要诀和技巧

1.execute执行的任务抛出异常

1.原理

测试代码：

public static void main(String[] args) {
        Executors.newFixedThreadPool(1);
        try {
            Executors.newFixedThreadPool(1).execute(new Runnable() {
                @Override public void run() {
                    int i=1/0;
                }
            });
        } catch (Exception e) {
            System.out.println("catch!!!!");
        } finally {
            System.out.println("normal");
        }
    }

这个异常会被内部吞掉的，不会被catch块catch到。
但是程序会用System.err和e.printStackTrace方式打印异常栈信息，是由下面这个方法触发的：

/**
     * 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);
    }

看注释，这个方法是用来分发处理一个uncaught的异常交由UncaughtExceptionHandler来处理，是由JVM底层来调用的。

具体的实现在ThreadGroup类中，有个uncaughtException方法，

/**
     * Called by the Java Virtual Machine when a thread in this
     * thread group stops because of an uncaught exception, and the thread
     * does not have a specific {@link Thread.UncaughtExceptionHandler}
     * installed.
     * <p>
     * Applications can override this method in subclasses of
     * <code>ThreadGroup</code> to provide alternative handling of
     * uncaught exceptions.
     *
     * @param   t   the thread that is about to exit.
     * @param   e   the uncaught exception.
     * @since   JDK1.0
     */
    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);
            }
        }
    }

先看注释，该方法是由JVM调用，当一个线程由于一个uncaught异常而导致线程终止，而且该线程没有指定一个UncaughtExceptionHandler。

在else if块中会用System.err和e.printStackTrace配合打印异常信息。

这种情况为了保证我们的程序在运行时能够感知异常，我们可以在我们的task的run方法中用try catch把语句包起来，然后在catch记录日志和监控。注意这里既是把线程包装一下重新跑出去也是没用的。

2.解决方案

自己把线程封装一下

/**
     * 第一种实现自己定义线程，同时自己定义一个ThreadFactory的实现呢
     */
    static class MyAppThread extends Thread {
        public static final String DEFAULT_NAME = "MyAppThread";
        private static final AtomicInteger created = new AtomicInteger();
        private static final AtomicInteger alive = new AtomicInteger();

        public MyAppThread(Runnable r) {
            this(r, DEFAULT_NAME);
        }

        public MyAppThread(Runnable runnable, String name) {
            super(runnable, name + "-" + created.incrementAndGet());
            this.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                public void uncaughtException(Thread t,
                        Throwable e) {
                    logger.error("UNCAUGHT1 in thread " + t.getName(), e);
                }
            });
        }

        public void run() {
            System.out.println("Created " + getName());
            try {
                alive.incrementAndGet();
                super.run();
            } finally {
                alive.decrementAndGet();
                System.out.println("Exiting " + getName());
            }
        }

        public static int getThreadsCreated() {
            return created.get();
        }

        public static int getThreadsAlive() {
            return alive.get();
        }
    }

自己封装线程的工厂类

public class MyThreadFactory2 {
        public Thread newThread(Runnable runnable) {
            Thread ret = Executors.defaultThreadFactory().newThread(runnable);
            ret.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                public void uncaughtException(Thread t,
                        Throwable e) {
                    logger.error("UNCAUGHT2 in thread " + t.getName(), e);
                }
            });
            return ret;
        }
    }

在构造线程池的时候，作为参数传递我们自己封装的线程工厂。

2.submit方法提交的任务中抛出异常

/**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

线程池的submit方法提交的任务是一个FutureTask，它既含有Runnable的任务属性也含有Future的属性。FutureTask的run方法中调用的是内部实现的AbstractQueuedSynchronizer的innerRun方法，

void innerRun() {
            if (!compareAndSetState(READY, RUNNING))
                return;

            runner = Thread.currentThread();
            if (getState() == RUNNING) { // recheck after setting thread
                V result;
                try {
                    result = callable.call();
                } catch (Throwable ex) {
                    setException(ex);
                    return;
                }
                set(result);
            } else {
                releaseShared(0); // cancel
            }
        }

所以call方法抛出异常的话，会被catch捕获并用setException进行异常的设置。在设置异常之后，用future的get(内部是Sync的innerGet方法)方法获取结果的时候会抛出异常，

V innerGet() throws InterruptedException, ExecutionException {
            acquireSharedInterruptibly(0);
            if (getState() == CANCELLED)
                throw new CancellationException();
            if (exception != null)
                throw new ExecutionException(exception);
            return result;
        }

所以为了确保外部感知到这个异常，有两个方法：

1.一定要是用future的阻塞的get方法来获取结果。如果调用带超时时间的get方法，如果异常在超时之后发生的话，外部也无法感知到这个异常。如果业务上在超时之后已经不关心这个异常了的话，也可以只对超时进行监控和日志输出。

2.对call方法内部进行try catch包裹，在有异常发生的时候，设置一个特殊值来表示异常发生情况下的返回，同时记录日志和监控。