ThreadPoolExecutor线程池源码分析

格式不好，重新整理了下格式： http://blog.youkuaiyun.com/wangjiang87/article/details/78672373

开始沉下心来好好分析jdk的类：

1.ThreadPoolExecutor中的主要变量：

runState:线程池的状态 有三种：RUNNING:0;SHUTDOWN:1;STOP:2;TERMINATED:3，默认是0；

BlockingQueue<Runnable> workQueue:所有要执行的任务；

HashSet<Worker> workers：池中所有的线程，它的数量和poolSize保持一致；

long keepAliveTime：当workers中的线程数量超过corePoolSize时，空闲时间超过这个字段的值的空闲线程就会被回收掉；

boolean allowCoreThreadTimeOut：是否允许核心线程数（corePoolSize）超时，如果值为true，当核心线程数超过keepAliveTime时，就会被回收，默认为false；

int corePoolSize：核心线程数，workers中的元素小于这个值时，有任务就新建线程；

int maximumPoolSize：线程池中的最大线程数，如果线程数超过此值，并且workQueue队列已满，则拒绝接受任务；

int poolSize:当前线程池中的线程数量，和workers中的元素数量一致；

2.创建ThreadPoolExecutor,建议使用Executors工厂类进行创建，也可以自己new，自己创建时需要设置合适的参数来保证线程池运行最优。

我们执行下面的初始化方法：

ThreadPoolExecutor executor = new ThreadPoolExecutor(3,8,60,TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(500), new ThreadPoolExecutor.CallerRunsPolicy()));

此方法执行之后，池中各主要变量的变化为：

runState:0; workQueue容量为500；workers为0；keepAliveTime:60秒；corePoolSize:3;maximumPoolSize:8 pooleSize:0

3.执行一次threadPoolExecutor.execute(Runnable)之后，各变量的变化：

workers中多了一个线程，poolSize为1；workQueue中没有元素，只有workers中的元素数量大于等于corePoolSize(3)时，才开始往workQueue中放元素；其他的主要变量在初始化之后，不再变化，以后变化的也就是workers、poolSize、workQueue、runState这四个变量。

4.分析execute()方法源码，来看看怎么使用这些变量的，主要有三种情况：(1)：poolSize<corePoolSize( 2):poolSize>=corePoolSize&&workQueue队列没满 (3):poolSize>=corePoolSize&&workQueue队列已满&&poolSize<maximumPoolSize

源码：

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {

if (runState == RUNNING && workQueue.offer(command)) {

if (runState != RUNNING || poolSize == 0)

ensureQueuedTaskHandled(command);

} else if (!addIfUnderMaximumPoolSize(command))

reject(command); // is shutdown or saturated

}

}

第一种情况：poolSize<corePoolSize

前三次

先看if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))这一行，在前三次（含第三次）执行execute方法时，poolSize >= corePoolSize这个条件是不成立的，因为corePoolSize设置的是3，而poolSize的初始值是0，每执行一次excute方法，poolSize加1。那接下来看后面的这个条件：!addIfUnderCorePoolSize(command)，此方法源码为：

private boolean addIfUnderCorePoolSize(Runnable firstTask) {

Thread t = null;

final ReentrantLock mainLock = this.mainLock;

mainLock.lock();

try {

if (poolSize < corePoolSize && runState == RUNNING)

t = addThread(firstTask);

} finally {

mainLock.unlock();

}

if (t == null)

return false;

t.start();

return true;

}

每次调用execute方法都会调用addIfUnderCorePoolSize方法，前三次执行到execute时，也及时前三次执行addIfUnderCorePoolSize方法时，if (poolSize < corePoolSize && runState == RUNNING)这个条件是成立的，会每次都执行到 t = addThread(firstTask);来新创建一个线程，然后启动线程，返回true。addIfUnderCorePoolSize方法执行完回到execute方法中调用的地方 !addIfUnderCorePoolSize(command)=false，所以前三次执行execute方法，只执行到 if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))就结束了，条件里的代码是不执行的。

回过头再看下 t = addThread(firstTask)这个方法：

private Thread addThread(Runnable firstTask) {

Worker w = new Worker(firstTask);

Thread t = threadFactory.newThread(w);

if (t != null) {

w.thread = t;

workers.add(w);

int nt = ++poolSize;

if (nt > largestPoolSize)

largestPoolSize = nt;

}

return t;

}

这个方法主要是将提交的任务封装到ThreadPoolExecutor的内部类Worker中，这个worker就是真正执行任务的线程，将worker放入workers中进行缓存，同时poolSize加1来记录池中线程的数量。

执行到的这些代码的意思也就明了了： 当池中的线程数小于核心线程数时，有任务提交时，任务既不会往workQueue中放，也不会使用workers中已有的空闲线程，而是直接新建线程来执行任务。

第二种情况：poolSize>=corePoolSize&&workQueue队列没满

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

if ( poolSize >= corePoolSize ||!addIfUnderCorePoolSize(command)) {

if ( runState == RUNNING && workQueue.offer(command)) {

if (runState != RUNNING || poolSize == 0)

ensureQueuedTaskHandled(command);

} else if (!addIfUnderMaximumPoolSize(command))

reject(command); // is shutdown or saturated

}

}

这种情况下addIfUnderCorePoolSize方法不会执行了， poolSize >= corePoolSize成立，直接进入判断条件内部，如果没有调用shutDown之类的方法，runState值依然是RUNNIING状态，并且将提交的任务放到任务队列workQueue中排队等待执行，execute方法执行结束。

第二种情况的意思就是： 当池中的线程数大于等于核心线程数时，会把任务提交到workQueue任务队列中排队等待被执行。

第三种情况：poolSize>=corePoolSize&&workQueue队列已满&&poolSize<maximumPoolSize

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

if (poolSize >= corePoolSize ||!addIfUnderCorePoolSize(command)) {

if ( runState == RUNNING &&workQueue.offer(command)) {

if (runState != RUNNING || poolSize == 0)

ensureQueuedTaskHandled(command);

} else if (!addIfUnderMaximumPoolSize(command))

reject(command); // is shutdown or saturated

}

}

这种情况下：runState==RUNNING依然成立，只不过workQueue.offer(command)会返回false，因为队列已经满了，从而开始执行到 else if (!addIfUnderMaximumPoolSize(command))这一行，看addIfUnderMaximumPoolSize方法的源码：

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {

Thread t = null;

final ReentrantLock mainLock = this.mainLock;

mainLock.lock();

try {

if (poolSize < maximumPoolSize && runState == RUNNING)

t = addThread(firstTask);

} finally {

mainLock.unlock();

}

if (t == null)

return false;

t.start();

return true;

}

addIfUnderMaximumPoolSize方法和addIfUnderCorePoolSize唯一不一样的地方就是前者是拿poolSize和maximumPoolSize比较，后者是拿poolSize和corePoolSize比较。

第三种情况表达的意思就是：池中的线程数大于等于核心线程数，并且任务队列也已满，且线程数小于最大线程数，就会继续创建worker线程来执行提交的任务。

如果任务队列满了，并且池中的线程数大于或等于最大线程数了，再提交的任务就会根据指定的策略来拒绝任务了。

以上是池中的线程增加的过程，那增加到最大线程数后，队列里没有要处理的任务了，线程数是怎么减下去的呢？这个就需要通过分析Worker内部类来了解了。

待续。。。