ThreadPoolExecutor参数解析

ThreadPoolExecutor是一个非常重要的类,用来构建带有线程池的任务执行器，通过配置不同的参数来构造具有不同规格线程池的任务执行器。

写在前面的是：

线程池和任务执行器，线程池的定义比较直接，可以看做多个线程的集合。而任务执行器的概念比较的具有针对性，它用来执行任务，通过对线程池的管理实现多任务的并发，是线程池的载体。

线程和任务的区别，线程不是任务，线程是用来执行任务的。

队列是用来存放任务的，不是用来存放线程的。

主要的几个参数解析：

• 核心线程数（core pool sizes）和最大线程数（maxmum  pool sizes）

一开始两者的存在很让人摸不着头脑，简单的想法是用一个线程数（pool size）表示线程池的大小不就完了吗，不到规定的线程数就创建新的线程来执行新的任务，到了规定的线程数就等待其他线程处理完成，怎么还出现两个控制线程数的参数？

那这两个参数是什么意思干什么用的？

核心线程数：这个数与上面那个简单想法中的数有一个共同点，就是如果当前线程数达不到核心线程数时，不会使用已有的空闲的线程（如果有的话），来了新任务就会创建新的线程。

如果当前线程数达到核心线程数，而且没有空闲线程，那么来了新任务是否要创建新的线程呢？这取决于两点：

1. 当前的任务队列是否已满。
2. 线程池的最大线程数。

通过这个问题可以引出最大线程数的概念

最大线程数 : 最大线程数是和任务队列匹配使用的，确切的说是和有长度限制的任务队列（即有界任务队列）匹配使用的。

补充回答上面的问题，ThreadPoolExecutor的线程池拥有一个任务队列，这个任务队列只有在当前线程数＞核心线程数的时候才开始使用，如果该线程池使用的任务队列是有界队列，比如10，那么当该队列被新任务填满时也就是说队列中有10个新任务时ThreadPoolExecutor才会创建一个新的线程来执行队列中的一个任务，如果再发生队列被填满，而且依旧没有空闲线程时ThreadPoolExecutor再次创建新的线程，一旦线程的数量等于最大线程数就不再创建新的线程了，如果此时队列中还有10个任务，那么新来的任务就会被拒绝(reject)。

上述是针对有界队列，如果这个任务执行器的队列是无界队列呢？

由于无界队列不会被填满，所以永远不能达到创建新线程所需要的条件，所以也就不会有新线程被创建，所以最大线程数在这种情况下也就失去了其存在的意义。

• 线程空闲存活时间（keepAliveTime）

在介绍上面的核心线程数和最大线程数时有提到空闲的线程，所谓空闲的线程就是执行完任务之后闲着的线程。

超过这个时间会使得那么核心线程之外的空闲线程被杀死，如果想把这个时间也作用在核心线程上需要设置allowCoreThreadTimeOut(boolean)为true

这里有必要说一下的是，任务执行器如何实现线程的重复利用，当任务执行器执行execute（task）的时候会创建一个worker，它是一个Runnable类，可以看做task的载体，worker包含一个thread对象，这个thread启动的时候执行worker本身的run方法，这样worker和线程就融为一体。当worker的thread start的时候，就会执行worker的run方法，而worker的run会调用任务执行器的runWorker（worker），并将自身传递过去，意思是任务执行器启动了一个worker，而线程重复利用关键就在runWorker中，在启动了一个worker后，worker会从任务执行器中寻找可以运行的任务，而一开始创建worker使用的task就是它的第一个任务。

下面是jdk1.7的源码

//执行一个任务 task

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true)) // 将task装配到一个worker中
                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);
    }

　

添加一个worker　

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            final ReentrantLock mainLock = this.mainLock;
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int c = ctl.get();
                    int rs = runStateOf(c);

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {//如果worker创建成功，就启动它的对应的thread
                    t.start(); //worker中的tread启动
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

运行worker

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {//这里是关键，使用一个while来寻找任务执行器中（主要还是从任务队列中获取）还未执行的task。
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }