我认为使用 ThreadPoolExecutor我们可以在构造函数中传递的 BlockingQueue 中或使用 execute 方法提交要执行的 Runnable。
另外我的理解是，如果任务可用，它将被执行。
我不明白的是:

public class MyThreadPoolExecutor {  

    private static ThreadPoolExecutor executor;  

    public MyThreadPoolExecutor(int min, int max, int idleTime, BlockingQueue<Runnable> queue){  
        executor = new ThreadPoolExecutor(min, max, 10, TimeUnit.MINUTES, queue);   
        //executor.prestartAllCoreThreads();  
    }  

    public static void main(String[] main){
        BlockingQueue<Runnable> q = new LinkedBlockingQueue<Runnable>();
        final String[] names = {"A","B","C","D","E","F"};  
        for(int i = 0; i < names.length; i++){  
            final int j = i;  
            q.add(new Runnable() {  

                @Override  
                public void run() {  
                    System.out.println("Hi "+ names[j]);  

                }  
            });         
        }  
        new MyThreadPoolExecutor(10, 20, 1, q);   
        try {  
            TimeUnit.SECONDS.sleep(5);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        /*executor.execute(new Runnable() {  

            @Override  
            public void run() {  

                System.out.println("++++++++++++++");  

            }   
        });  */
        for(int i = 0; i < 100; i++){  
            final int j = i;  
            q.add(new Runnable() {   

                @Override  
                public void run() {  
                    System.out.println("Hi "+ j);  

                }  
            });  
        }   


    }  


}

除非我在构造函数中取消注释 executor.prestartAllCoreThreads(); 或者我调用 execute 打印 System.out.println("++++++++++++++");(也被注释掉了)。

为什么？
引用(我的重点):

By default, even core threads are initially created and started only when new tasks arrive, but this can be overridden dynamically using method prestartCoreThread() or prestartAllCoreThreads(). You probably want to prestart threads if you construct the pool with a non-empty queue.

好的。所以我的队列不是空的。但是我创建了 executor，我执行了 sleep，然后我将新的 Runnable 添加到队列中(循环到 100)。
此循环是否算作新任务到达？
为什么它不起作用，我必须 prestart 或显式调用 execute？

最佳答案

工作线程是在任务到达时产生的，这些线程与底层工作队列进行交互。如果您从非空工作队列开始，则需要预先启动工作人员。查看implementation in OpenJDK 7 .

我再说一遍，工作人员是与工作队列交互的人员。它们仅在通过 execute 传递时按需生成。 (或它上面的层，例如 invokeAll、submit 等)如果它们没有启动，添加到队列中的工作量并不重要，因为有没有检查它，因为没有 worker 开始。

ThreadPoolExecutor 不会生成工作线程，除非有必要，或者如果您通过 prestartAllCoreThreads 方法抢先创建工作线程和 prestartCoreThread .如果没有工作人员启动，那么队列中的任何工作都无法完成。

添加初始 execute 的原因是它强制创建一个唯一 核心工作线程，然后它可以开始处理队列中的工作。您也可以调用 prestartCoreThread 并收到类似的行为。如果您想启动所有 worker，您必须调用prestartAllCoreThreads 或通过execute 提交该数量的任务。

请参阅下面的执行代码。

/**
 * Executes the given task sometime in the future.  The task
 * may execute in a new thread or in an existing pooled thread.
 *
 * If the task cannot be submitted for execution, either because this
 * executor has been shutdown or because its capacity has been reached,
 * the task is handled by the current {@code RejectedExecutionHandler}.
 *
 * @param command the task to execute
 * @throws RejectedExecutionException at discretion of
 *         {@code RejectedExecutionHandler}, if the task
 *         cannot be accepted for execution
 * @throws NullPointerException if {@code command} is null
 */
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);
}

关于java - ThreadPoolExecutor 和队列，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11820120/