Common Pool对象池的中断策略和ThreadPoolExecutor中断策略

题记：

     看到摊子里gogole_09同学分享了他阿里的面筋，其中有个问题提到：线程池的中断策略有哪些？各有什么特点？想想自己也看过Common的对象池源码和用过Sun的ThreadPoolExecutor线程池，却没注意到“中断策略”，这是一个所有缓存池需要考虑的异常问题。

 

Common Pool中断策略

    竟然是中断策略，直接看Common Pool中的borrowObject，从池中取对象，当没有可用的对象的时候的策略。

   

    **StackObjectPool（以Stack为存储结构的Pool）

   

   public synchronized Object borrowObject() throws Exception {
     ....
    Object obj = null;// 取对象
   ...
     obj = _factory.makeObject(); // 制造对象
     newlyCreated = true;
     if (obj == null) {
                    throw new NoSuchElementException("PoolableObjectFactory.makeObject() returned null.");
                  }
     ....
     _numActive++;
     return obj;

 

发现_factory.makeObject(); 这个方法是一个abstract，所以猜测Common Pool并未实现自己的中断策略，而由使用者自行扩展。

 

 

ThreadPoolExecutor中断策略

    JDK提供了4种策略，分别是：

    1、CallerRunsPolicy

    2、AbortPolicy 中止任务

    3、DiscardPolicy 丢弃任务

    4、DiscarOldestPolicy 丢弃最老任务

 

分析中断策略，直接查看ThreadPoolExecutor类中的execute(Runnable command)设计，如下：

 /**
     * The default rejected execution handler
     */
private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
....
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        for (;;) {
            if (runState != RUNNING) {
                reject(command);
                return;
            }
            if (poolSize < corePoolSize && addIfUnderCorePoolSize(command))
                return;
            if (workQueue.offer(command))
                return;
            Runnable r = addIfUnderMaximumPoolSize(command);// 当线程大小超过maximumPoolSize时，返回null
            if (r == command)
                return;
            if (r == null) {
                reject(command);// 执行中断策略
                return;
            }
            // else retry
        }
    }

 

reject方法为：

void reject(Runnable command) {
        handler.rejectedExecution(command, this);// 直接调用接口RejectedExecutionHandler的rejectedExecution方法
}

 

4种中断策略的实现，首先，默认的AbortPolicy implements RejectedExecutionHandler

 public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always.
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException();// 直接抛出异常
        }
    }

 这种策略会让程序抛出异常，会一定程度影响系统运行。

 

然后CallerRunsPolicy策略：

public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {// 只要ThreadPoolExecutor没有关闭，就马上执行新线程，注意这里是run，而非start，新线程会立马执行
                r.run();
            }
        }
    }

 这个策略比较保守，不抛出异常，也不忽略线程，而是让线程直接运行抢占CPU而发生阻塞。

 

DiscardPolicy策略（忽略当前线程）：

public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a <tt>DiscardPolicy</tt>.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {// 直接忽略
        }
    }

这种策略被忽略，而不给出任何警告信息。

 

最后一个DiscardOldestPolicy策略（忽略最老线程）

 public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();// 直接移除当前队列中头节点
                e.execute(r);// 把新线程加入到队列的尾节点，并调用线程的start方法启动
            }
        }
    }

 

结论：

从代码中看：

    当线程数量小于pool中活动线程数，则创建新线程；

    当线程数量等于pool中活动线程数，则尝试把任务加入到任务队列里面；

    当任务队列满的时候，则执行中断策略进行调整。

    各自的策略都有不同的特点，根据系统的需求选择合适的策略以达到线程利用率的最优。