支持生产阻塞的线程池

在生产 - 消费者问题中

newFixedThreadPool的构造参数里的nThreads是最大同时工作的线程数，如果工作线程已满，新提交的任务会被放到一个无界的LinkedBlockingQueue里（等待队列）

如果生产速度大于消费速度，那么会发生任务堆积，等待队列会扩展到内存耗尽

naive的想法是，自定义线程池，将等待队列设置为有界的BlockingQueue，那么新提交的任务会被block住，直到工作线程空出来为止

但是如果去看J.U.C的源码，ThreadPoolExecutor.execute(Runnable)方法

 

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

可以看到，第30行调用的是workQueue的非阻塞的offer方法。

所以如果队列已满，新提交的任务不会被block住，反而会调用后续的reject流程。

如果我们想要达到阻塞生产者的目的的话，要么用信号量之类的东西限制同时进入线程池等待队列的任务数
要么加入线程池的等待策略

可以使用CallerRunsPolicy，让提交任务的线程来运行任务
也可以自定义等待策略，把新加入的任务put到等待队列里，这样就可以阻塞住生产者

 

范例代码如下

        int corePoolSize = 30;
        int waitQueueSize = 100000;
        ExecutorService pool = new ThreadPoolExecutor(corePoolSize, corePoolSize, 1, TimeUnit.DAYS,
                new LinkedBlockingQueue<Runnable>(waitQueueSize), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                if (!executor.isShutdown()) {
                    try {
                        executor.getQueue().put(r);
                    } catch (InterruptedException e) {
                        // should not be interrupted
                    }
                }
            }
        });

 

参考资料

http://ifeve.com/blocking-threadpool-executor/