ThreadPoolExecutor线程池源码分析

开始沉下心来好好分析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内部类来了解了。
待续。。。