Java线程池：ThreadPoolExecutor源码分析

用过java线程的同学都应该大致了解，在java中，为了合理使用线程以合理利用资源、提高吞吐率以及加快响应时间，通常会使用java线程池，因为线程池架构设计合理，比起自己创建线程可能花销巨大来讲，线程池是一个很好的选择。

作为一只喜欢研究源码的程序猿，就我所学，来讲讲java线程池是如何巩工作的。

一．4种线程池

首先，java线程池为我们量身定制了4中拿来即用的线程池：

1.newSingleThreadExecutor:

public static ExecutorServicenewSingleThreadExecutor() {

            return new FinalizableDelegatedExecutorService

                   (new ThreadPoolExecutor(1, 1,

                                0L, TimeUnit.MILLISECONDS,

                                new LinkedBlockingQueue()));

}

2.newFixedThreadPool:

public static ExecutorServicenewFixedThreadPool(int nThreads) {

            return new ThreadPoolExecutor(nThreads, nThreads,

                                  0L, TimeUnit.MILLISECONDS,

                                  new LinkedBlockingQueue());

}

3.newCachedThreadPool:

public static ExecutorServicenewCachedThreadPool() {

            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                  60L, TimeUnit.SECONDS,

                                  new SynchronousQueue());

}

4. newScheduledThreadPool:

public static ScheduledExecutorServicenewSingleThreadScheduledExecutor() {

            return new DelegatedScheduledExecutorService

                        (new ScheduledThreadPoolExecutor(1));

}

可以发现：除了newScheduledThreadPool，其他三个都是ThreadPoolExecutor的一种特殊实现。

二．ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,

                          int maximumPoolSize,

                          long keepAliveTime,

                          TimeUnit unit,

                          BlockingQueue workQueue,

                          ThreadFactory threadFactory,

                          RejectedExecutionHandler handler) {

if (corePoolSize <0 ||

maximumPoolSize <=0 ||

maximumPoolSize < corePoolSize ||

keepAliveTime <0)

throw new IllegalArgumentException();

    if (workQueue ==null || threadFactory ==null || handler ==null)

throw new NullPointerException();

    this.acc = System.getSecurityManager() ==null ?

null :

AccessController.getContext();

    this.corePoolSize = corePoolSize;

    this.maximumPoolSize = maximumPoolSize;

    this.workQueue = workQueue;

    this.keepAliveTime = unit.toNanos(keepAliveTime);

    this.threadFactory = threadFactory;

    this.handler = handler;

}

1.构造函数参数说明：

1).corePoolSize:线程池中的核心线程数

2).maximumPoolSize:线程池中的最大线程数

3).keepAliveTime: 线程池中的线程的存活时间

4).unit: keepAliveTime的时间单位

5).workQueue: BlockingQueue的实现，用于存储任务

6).threadFactory:自定义线程的创建工厂

7).handler:线程池的饱和策略，当阻塞队列满了，且没有空闲的线程，继续提交任务时，必须进行处理，默认的方式是抛出RejectedExecutionHandler异常

2.内部状态变量说明：

jdk1.8就是用一个int型来表示线程池的运行状态和运行任务数量，一个int一共32位，前3位表示运行状态，后29位表示运行任务线程数；运行状态和运行任务线程数量分别通过runStateOf(int c)和workerCountOf(int c)来获取，都是通过&操作来计算的。各个值的初始值分为如下：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

private static final int COUNT_BITS = Integer.SIZE - 3;

private static final int CAPACITY = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits

private static final int RUNNING = -1 << COUNT_BITS;

private static final int SHUTDOWN = 0 << COUNT_BITS;

private static final int STOP = 1 << COUNT_BITS;

private static final int TIDYING = 2 << COUNT_BITS;

private static final int TERMINATED = 3 << COUNT_BITS;

// Packing and unpacking ctl

private static int runStateOf(int c) { return c & ~CAPACITY; }

private static int workerCountOf(int c) { return c & CAPACITY; }

private static int ctlOf(int rs, int wc) { return rs | wc; }

 1).ctl:包装任务状态和线程数（高3位表示运行状态，后29位表示运行任务线程数），初始值：11100000000000000000000000000000，没多一线程就加1，为原子操作；默认AtomicInteger,如果数量不够的话，可以自行改成AtomicLong

  2).COUNT_BITS:29

  3).CAPACITY:运行任务线程数,值为：000 11111111111111111111111111111

  4).RUNNING:运行状态，       值为：111 00000000000000000000000000000

  5).SHUTDOWN:关闭状态，  值为：0

  6).STOP: 停止状态，             值为：001 00000000000000000000000000000

  7).TIDYING:整理状态，         值为：010 00000000000000000000000000000

  8).TERMINATED:终止状态，值为：011 00000000000000000000000000000

3.内部公用函数说明：

1).runStateOf(int c):获取运行状态，

2).workerCountOf(int c):获取运行任务线程数

3).ctl(int rs,int wc): 包装运行状态和任务线程数

4).runStateLessThan(int c,int s):是否小于某个状态

5).runStateAtLesat(int c,int s):是否大于或者等于某个状态

这些公共函数接下来都会用到，写在这里是便于理解。

4.提交任务函数：execute(Runnable command)

public void execute(Runnable command){

    if (command == null)

        throw new NullPointerException();

    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);

}

1).如果当前运行任务线程数小于corePoolSize，尝试另起线程去运行任务。调用addWorker函数会自动检查运行状态和运行任务线程数，防止添加线程时出现多线程操作错误。

2).如果添加新的线程失败，那么就将该任务添加到队列中，同时，还需要检查运行状态和运行任务线程数；再次检查状态，防止入列期间出现状态改变情况，如果线程池处于非运行状态，移除任务；如果没有运行任务线程数量为0，则起一个新的线程。

3).如果任务不能进入队列(例如队列满了)，再次尝试另起一个线程运行；如果失败了，使用拒绝策略。

5.addWorker

在execute函数中，addWorker是另起线程去执行任务，它的具体实现如下：

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 {

        w = new Worker(firstTask);

        final Thread t = w.thread;

        if (t != null) {

            final ReentrantLock mainLock = this.mainLock;

            mainLock.lock();

            try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired.

                    int rs = runStateOf(ctl.get());

                    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) {

                    t.start();

                    workerStarted = true;

                }

            }

        } finally {

            if (! workerStarted)

            addWorkerFailed(w);

            }

            return workerStarted;

}