ThreadPoolExecutor一些原理问题

今天被同事问到，ThreadPoolExecutor是怎么在线程执行后，保存线程的； worker线程去调用具体的业务线程，是不是就启动了两次线程。

平时用的比较多的是用ExecutorService 来创建newCachedThreadPool(), newFixedThreadPool(), SingleThreadExecutor()等

看了一下源代码，这几个建线程池的方法都是创建ThreadPoolExecutor

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) 

corePoolSize就是运行的核心线程的数，maximumPoolSize就是最大线程数，keepAliveTime是空闲线程的等待时间，workQueue是用来存放等待线程的。

当poolSize<corePoolSize时，每新来一个任务，则会创建一个工作线程(worker)来处理当前的任务， worker 处理完第一个线程后，会处理queue里的线程。worker在keepAliveTime的时间内，如果没有收到新的任务，则该worker会消失

1. ThreadPoolExecutor是怎么在线程执行后，一直保留worker线程(小于corePoolSize)存活的?

答案在getTask方法的代码里：

Runnable getTask() {
        for (;;) {
            try {
                int state = runState;
                if (state > SHUTDOWN)
                    return null;
                Runnable r;
                if (state == SHUTDOWN)  // Help drain queue
                    r = workQueue.poll();
                else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
                    r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
                else
                    r = workQueue.take();
                if (r != null)
                    return r;
                if (workerCanExit()) {
                    if (runState >= SHUTDOWN) // Wake up others
                        interruptIdleWorkers();
                    return null;
                }
                // Else retry
            } catch (InterruptedException ie) {
                // On interruption, re-check runState
            }
        }
    }

当前的线程数<corePoolSize时， workerCanExit()返回false, 无条件循环到   r = workQueue.take();  take是阻塞方法 ，因此work的线程会一直等待，   不会退出， 等到queue里任务后再执行。

2. worker线程去调用具体的业务线程，是不是就启动了两次线程

注意: worker线程会去调用任务线程里的run方法。而不是start方法。从而避免了多次创建线程

private void runTask(Runnable task) {
            final ReentrantLock runLock = this.runLock;
            runLock.lock();
            try {
                /*
                 * Ensure that unless pool is stopping, this thread
                 * does not have its interrupt set. This requires a
                 * double-check of state in case the interrupt was
                 * cleared concurrently with a shutdownNow -- if so,
                 * the interrupt is re-enabled.
                 */
                if (runState < STOP &&
                    Thread.interrupted() &&
                    runState >= STOP)
                    thread.interrupt();
                /*
                 * Track execution state to ensure that afterExecute
                 * is called only if task completed or threw
                 * exception. Otherwise, the caught runtime exception
                 * will have been thrown by afterExecute itself, in
                 * which case we don't want to call it again.
                 */
                boolean ran = false;
                beforeExecute(thread, task);
                try {
                    task.run();
                    ran = true;
                    afterExecute(task, null);
                    ++completedTasks;
                } catch (RuntimeException ex) {
                    if (!ran)
                        afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                runLock.unlock();
            }
        }