线程池源码分析

线程池分析

线程池的核心类是ThreadPoolExecutor，该类中有一个AtomicInteger类型的变量，其高三位用来表示线程池的状态，低29位表示线程池中线程的个数。

线程池总共有如下几种状态，用高三位来表示：

    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;

• RUNNING：接收新任务，处理阻塞队列中的任务
• SHUTDOWN ： 不接收新任务，但是会处理阻塞队列中的任务
• STOP ： 不接收新的任务，且会中断正在执行的任务，丢弃队列中的任务
• TIDYING：所有的任务执行完，线程池中的线程数为0
• TERMINATED：线程池彻底终止terminated方法调用后的状态

一个int变量同时表示线程状态和线程个数，并发修改时，不用加锁，操作系统对于int类型的修改是原子的。
线程池中会将提交过来的runable对象封装成一个worker，而worker也是实现了Runnable接口的，在其run方法中会调用提交过来的任务的run方法。work会放到一个线程不安全的容器hashset中，对于写操作需要加锁。

1、execute方法

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

方法参数就是用户提交的Runnable对象，提交到线程池中将要执行的任务。首先进行参数校验，如果command为null抛出异常。
获取线程池中线程的状态和线程池中线程总个数的组合值，通过这个组合值可以分别得出线程池的线程个数，和当前线程池的状态。workerCountOf用来计算当前线程池中的线程个数，如果小于核心线程数，则创建一个核心线程去执行这个任务。
否则判断线程池是否处于运行状态，非Running状态的线程池是要丢弃新任务的。处于Running状态，则把任务添加到阻塞队列中，成功后，再进行二次校验，因为在添加的过程中，线程池的状态可能会发生改变。若发生改变会把刚提交的任务移除掉，如果移除成功触发拒绝策略，如果移除失败，创建一个线程去执行。
如果线程池依然是Running状态，判断线程池中是否有线程，如果没有的话，则创建一个非核心线程去执行任务。最后如果阻塞队列已满的话，尝试新增非核心线程，如果失败执行拒绝策略。失败的原因就是线程池中的总的线程个数等于最大线程数了。

有几个点需要注意：1、线程池的核心线程池的个数可以设置为0的。2、提交过程中会判断线程池的状态是否满足条件。

2、addWork方法

该方法是将提交过来的任务，包装成一个Work对象，并执行。Work这个类的组成：

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
}

work是线程池中的一个内部类，实现了Runnable接口，继承 了AQS实现了非重入独占锁，因为可能存在多线程同时提交任务。
addWork方法再提交任务成功后，返回true，否则返回false。首先会使用cas增加线程数目，然后将提交过来的任务包装成一个work对象，这个work对象的构造方法中，会通过线程工厂创建一个线程，并且把this传进去，而这个this就是当前的work对象，并且把创建的work对象存到一个hashset中，不管是核心线程还是非核心线程都会存进去。
然后调用start方法执行起来，进而调用到run方法，进而调用到runwork方法，将任务交给线程运行。
其中在addWork的时候会判断此次增加的是一个核心线程还是一个非核心线程，通过方法参数中的一个boolean值控制。

3、runWorker方法

这个方法中隐藏这个线程池的线程为什么能一直运行的秘密，传统的线程在执行完run方法后，就自动销毁了，而核心线程却可以不断的执行任务。

 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) {
                w.lock();
                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);
        }
    }

task就是用户提交过来的任务，任务第一次是不为null的，因此执行task.run方法，在执行前可以进行前置拦截和后置拦截，进行一些增强。执行完run方法后，将task设为null，对执行的任务数量进行统计，然后继续上面的循环，此次会执行getTask方法，这个方法就是从队列中去取任务，然后执行，这也就是为什么线程池的线程能一直执行的原因。
如果执行到finally块，也就是当前线程池中的线程数超过了核心线程，且空闲时间超过了keepalivetime，会进行回收操作。

4、getTask方法

getTask方法说明了为什么非核心线程在一段时间没有任务执行后会被销毁。

 boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
   Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();

核心就是上面的代码，其中allowCoreThreadTimeOut默认为false的，wc表示当前线程池中的线程数量，如果数量大于核心线程数，则执行带超时的poll方法，这样一段时间没有任务的话会返回null，然后等待执行的线程就会执行完毕，进而销毁，否则会执行take方法，该方法会一直阻塞，这也就是为什么核心线程会不断存在的原因。

其实并没有核心线程和非核心线程的区分，只是通过数量来判断是否该回收线程，回收的线程就被成为非核心线程,可以设置allowCoreThreadTimeOut为true，这样每个线程在固定的时间内拿不到任务就会被回收。

当超时后，则拿到的任务就是个null，执行销毁逻辑，从hashset中将该work对象移除，