线程池原理+JDK1.8源码解析

线程池创建的方式：

public ThreadPoolExecutor(int corePoolSize,
                            int maximumPoolSize,
                              long keepAliveTime,
                               TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                               RejectedExecutionHandler handler) 

参数的介绍：

corePoolSize：线程池核心线程数

maximumPoolSize：线程池最大线程数

keepAliveTime：非核心线程数，空闲多久会被回收

unit：空闲时间的单位

workQueue：线程池等待队列的大小

handler：线程池达到饱和的策略处理类

线程池原理：

先看下面一张流程图：

1.当一个任务过来时，先判断当前线程池的核心线程数是否已经创建满了

    如果没有满，直接创建线程，进行任务处理；如果满了，进入到第二步

    注意：这里即使当前创建过的线程有空闲的，依然会重新创建线程执行任务，而不是拿空闲线程来用。

2.判断当前的线程池队列是否满了，没有满，任务加入到队列中进行排队；如果满了，进入到第三步

3.判断当前线程池行程数量是否达到了最大线程数，如果没有达到，创建线程执行当前任务，如果达到了，进入第4步处理

4.按照配置的饱和处理策略，进行处理

JDK1.8源码解析：

先看ThreadPoolExecutor的内部状态实现方式：

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

我们可以看到这里有一个AtomicInteger类型的ctl 变量：int一共是32位，这里采用的是低位29位表示线程池线程的个数，高3位表示当前线程池的状态。

COUNT_BITS：我们看这个常量，它的值=32-3=29

RUNNING    = -1 << COUNT_BITS; 这里表示高3位是111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；
SHUTDOWN   =  0 << COUNT_BITS;这里表示高3位是000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
STOP       =  1 << COUNT_BITS;这里表示高3位是001，该状态的线程池不会接收新任务，也不会处理阻塞队列中的任务，并且会中断正在运行的任务；
TIDYING    =  2 << COUNT_BITS;这里表示高3位是010，表示当前线程池所有任务都已经终止了；
TERMINATED =  3 << COUNT_BITS;这里表示高3位是011，表示erminated()方法已经执行完成 ；

运行流程解析：

1.ThreadPoolExecutor的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();
        }
        //这里需要判断当前线程池的状态=RUNNING，并且把当前任务加入到任务队列里
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //如果线程池不是RUNNING状态，成功从阻塞队列中删除任务，执行reject方法处理任务
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //线程池处于running状态，但是没有线程，则创建线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //队列也满了，这个时候会创建非核心线程去执行任务  
        //如果失败，直接走饱和拒绝策略处理
        else if (!addWorker(command, false))
            reject(command);
    }

注意：这里做了双重检查，是因为多线程环境下，线程池的状态是随时变化的，而获取状态跟下面操作是非原子性的，如果不做双层check，可能会出现线程变成了非运行状态，结果却把任务放到了执行任务队列里，导致任务无法执行。且不会通知到调用端。

2.addwork()方法：主要是创建线程并执行任务

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

            // Check if queue empty only if necessary.
            //如果当前线程池状态是非运行状态并且
            //状态是shutdown状态而且任务不为空，队列是空的 直接return失败
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                //获取当前运行中的线程数
                int wc = workerCountOf(c);
                //线程数跟配置大小作比较
                //如果大于等于最大数  或者 通过传入的参数  来跟核心线程数和最大线程数做比较 当前线程数超过配置值时  直接return失败
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //通过CAS来增加当前线程池里线程的数量 修改成功  直接跳出当前循环
                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 {
            //创建一个Worker对象，传入当前的任务
            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());
                    //如果当前状态是运行中  或者 （是shutdown 并且任务为空的话）
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        //如果当前线程是已经运行中的  抛出异常
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        //一切正常  把当前worker加入到set中
                        workers.add(w);
                        //如果set的大小大于最大线程大小的时候 扩大当前值
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    //释放锁
                    mainLock.unlock();
                }
                //任务加入到worker成功  执行当前线程
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

注意：这里在添加到set的时候，做了加锁处理，这里主要是需要准确判断当前线程池的状态，在此处执行的时候，不容许其他线程修改当前线程池的状态，已达到正确性。

3.worker.runWorker()方法，这个是执行任务的核心方法：

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        //这里是修改worker的状态  容许当前任务被线程池打断
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //当前需要执行的任务不为空
            //这里用的是个while 如果传入的任务为空的话
            //会从线程池队列里拿出任务来处理
            while (task != null || (task = getTask()) != null) {
                //加锁 在执行的时候  不容许被其他线程打断
                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);
        }
    }

整体流程为：

1.获取当前任务；

2.线程启动之后，通过unlock方法释放锁，设置AQS的state为0，表示运行可中断； 

3.执行传入的任务，或者是直接从线程池的任务队列里面获取任务执行；

4.给当前线程加锁，保证不会被其他前程中断（如果线程池直接中断，这里也会中断）；

5.检查当前线程池的状态，如果当前线程池是中断状态，这直接中断当前线程；

6.执行beforeExecute方法

7.执行当前任务的run方法

8.执行afterExecute方法 

9.解锁  容许被其他线程中断

4.我们看一下从任务队列里面获取任务的方法：getTask()

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            //这里还是需要判断当前线程池的状态 
            //如果是非运行状态，并且是（中断正状态或者是任务队列为空）
            //返回空
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            //查看当前运行中状态的线程个数
            int wc = workerCountOf(c);

            // Are workers subject to culling?
            //如果配置了容许线程会被回收  或者 当前线程数大于核心线程数
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            //如果当前线程数大于最大线程数 或者是达到了回收的条件
            //而且线程数量大于1 或者 任务队列已经空了
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                //如果线程不允许无休止空闲timed == true, workQueue.poll任务：如果在keepAliveTime时间内，阻塞队列还是没有任务，则返回null
                //如果线程允许空闲等待而不被销毁timed == false，workQueue.take任务：如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务，并执行；
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }