线程池原理分析——线程是如何做到复用的

通过上篇文章的学习，我们初步认识了jdk提供的几种线程池的使用，接下来，我们来深入研究下：

开始之前，我们再来回顾下线程池的参数，方便后面理解线程池的运行原理。

核心线程（corePool）：有新任务提交时，首先检查核心线程数，如果核心线程都在工作，而且数量也已经达到最大核心线程数，则不会继续新建核心线程，而会将任务放入等待队列。

非核心线程/最大线程数（maximumPoolSize）：当等待队列满了，如果当前线程数没有超过最大线程数，则会新建线程执行任务，那么核心线程和非核心线程到底有什么区别呢？说出来你可能不信，本质上它们没有什么区别，创建出来的线程也根本没有标识去区分它们是核心还是非核心的，线程池只会去判断已有的线程数（包括核心和非核心）去跟核心线程数和最大线程数比较，来决定下一步的策略。

线程活动保持时间 (keepAliveTime)：线程空闲下来之后，保持线程的持续时间，超过这个时间还没有任务执行，该工作线程结束。

等待队列 (workQueue)：等待队列用于存储当核心线程都在忙时，继续新增的任务，核心线程在执行完当前任务后，也会去等待队列拉取任务继续执行，这个队列一般是一个线程安全的阻塞队列，它的容量也可以由开发者根据业务来定制。

拒接策略 (RejectedExecutionHandler)：当等待队列已满，线程数也达到最大线程数时，线程池会根据拒接策略来执行后续操作，默认的策略是直接抛弃要加入的任务

线程池执行任务的流程图

源码分析：

    //CAS，无锁并发  高3位记录线程池的生命状态,低29位记录活动线程数
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    //表示线程池线程数的bit数
    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
    //1110 0000 0000 0000 0000 0000 0000 0000
    private static final int RUNNING    = -1 << COUNT_BITS;
    //0000 0000 0000 0000 0000 0000 0000 0000
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    //0010 0000 0000 0000 0000 0000 0000 0000
    private static final int STOP       =  1 << COUNT_BITS;
    //0100 0000 0000 0000 0000 0000 0000 0000
    private static final int TIDYING    =  2 << COUNT_BITS;
    //0110 0000 0000 0000 0000 0000 0000 0000
    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; }
    //组装状态和数量，成为ctl
    private static int ctlOf(int rs, int wc) { return rs | wc; }

    /*
     * Bit field accessors that don't require unpacking ctl.
     * These depend on the bit layout and on workerCount being never negative.
     * 判断状态c是否比s小，下面会给出状态流转图
     */
    
    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }
    
    //判断状态c是否不小于状态s
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
    //判断线程是否在运行
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }

 

线程池的生命状态

有5种：

1. RUNNING：运行状态，值也是最小的，刚创建的线程池就是此状态。
2. SHUTDOWN：停工状态，不再接收新任务，已经接收的任务会继续执行
3. STOP：停止状态，不再接收新任务，已经接收正在执行的任务，也会中断
4. Tidying：清空状态，所有任务都停止了，工作的线程也全部结束了，ctl=0
5. TERMINATED，终止状态，线程池已销毁

向线程池提交任务有这2种方式，execute是ExecutorService接口定义的，submit有三种方法重载都在AbstractExecutorService中定义，都是将要执行的任务包装为FutureTask来提交，使用者可以通过FutureTask来拿到任务的执行状态和执行最终的结果，最终调用的都是execute方法，其实对于线程池来说，它并不关心你是哪种方式提交的，因为任务的状态是由FutureTask自己维护的，对线程池透明。

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

execute的实现

也就是上面流程图的实现

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        //第一步，获取ctl
        int c = ctl.get();
        //如果活动线程数小于核心数，新建线程执行任务
        if (workerCountOf(c) < corePoolSize) {
            //提交任务后，会优先启动核心线程处理
            if (addWorker(command, true))//addWorker:创建线程执行任务 true/false用来判断是创建核心线程还是最大线程
                return;//新建成功，直接return
            //如果添加任务失败，刷新ctl，进入下一步
            c = ctl.get();
        }
        //检查线程池是否是运行状态，然后将任务添加到等待队列，注意offer是不会阻塞的
        if (isRunning(c) && workQueue.offer(command)) {
           //任务成功添加到等待队列，再次刷新ctl
            int recheck = ctl.get();
           //双重检测，如果线程池不是运行状态，则将刚添加的任务从队列移除并执行拒绝策略
            if (!isRunning(recheck) && remove(command))
                reject(command);
            //判断当前活动线程数量，如果当前活动线程数量为0（既没有线程去执行当前的任务了），则添加一个非核心线程（因为核心线程数已经满了），并且不指定首次执行任务。因为要执行的任务已经添加到等待队列里了
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
       //走到这说明核心线程数和等待队列都满了，添加非核心线程，指定首次执行任务，如果添加失败，执行异常策略
        else if (!addWorker(command, false))
            reject(command);
    }
    

可以看到execute方法中没有用到重量级锁，ctl虽然可以保证本身变化的原子性，但是不能保证方法内部的代码块的原子性，是否会有并发问题？

execute方法虽然没有加锁，但是在addWorker方法内部，加锁了，这样可以保证不会创建超过我们预期的线程数

addWorker 方法

private boolean addWorker(Runnable firstTask, boolean core) {
       //相当于goto，虽然不建议滥用，但这里使用又觉得没一点问题
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            //如果线程池的状态到了SHUTDOWN或者之上的状态时候，只有一种情况还需要继续添加线程，那就是线程池已经SHUTDOWN，但是队列中还有任务在排队,而且不接受新任务（所以firstTask必须为null）
           //这里还继续添加线程的初衷是，加快执行等待队列中的任务，尽快让线程池关闭
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
               //传入的core的参数，唯一用到的地方，如果线程数超过理论最大容量，如果core是true跟最大核心线程数比较，否则跟最大线程数比较，很好理解
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //通过CAS自旋，增加线程数+1，增加成功跳出双层循环，继续往下执行
                if (compareAndIncrementWorkerCount(c))
                    break retry;
               //检测当前线程状态如果发生了变化，则继续回到retry，重新开始循环
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        //以上代码了解即可



        //走到这里，说明我们已经成功的将线程数+1了，但是真正的线程还没有被添加
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
           //添加线程，Worker是继承了AQS，实现了Runnable接口的包装类
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
               //到这里开始加锁
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int rs = runStateOf(ctl.get());
                    //检查线程状态，还是跟之前一样，只有当线程池处于RUNNING，或者处于SHUTDOWN并且firstTask==null的时候，这时候创建Worker来加速处理队列中的任务
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                       //线程只能被start一次
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                      //workers是一个HashSet，添加我们新增的Worker
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                  //启动Worker
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

由此可以看出：创建线程的时候，传入的并不是我们给线程池的那个 Runnable 对象，而是 Worker 对象本身，也就是说线程 start 的时候，Worker 类的 run 方法会被执行

线程池是如何创建线程、执行任务的

execute(任务)->addWorker(任务)

                         ->new Worker(任务)->worker.firstTask = 任务  worker.thread = this(当前worker)

 private boolean addWorker(Runnable firstTask, boolean core) {
       //...
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;//为worker本身
            if (t != null) {
                //...
                if (workerAdded) {
                    t.start();//执行的是runWorker()方法
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

t.start()执行的是Worker 的run(),最终执行runWorker

构造函数：

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        ....   
       
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);//传入的是 Worker 对象本身
        }
        public void run() {
            runWorker(this);
        }
        ...
}

runWorker里，先task = getTask()获取任务，然后task.run()，执行我们的任务，注意：这里是直接调用的run方法，而不是start

继续看Worker是怎么工作的

//Worker的run方法调用的是ThreadPoolExecutor的runWorker方法
    public void run() {
          runWorker(this);
    }

    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 {
            //如果task不是null，或者去队列中取任务，注意这里会阻塞，后面会分析getTask方法，重点
            while (task != null || (task = getTask()) != null) {
               //这个lock在这里是为了如果线程被中断，那么会抛出InterruptedException，而退出循环，结束线程
                w.lock();
                //判断线程是否需要中断
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                   //任务开始执行前的hook方法
                    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 {
                       任务开始执行后的hook方法
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
           //Worker退出
            processWorkerExit(w, completedAbruptly);
        }
    }

  

getTask() 方法

其实就是从阻塞队列中取出 Runnable 对象 

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

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

           //检查线程池的状态，如果已经是STOP及以上的状态，或者已经SHUTDOWN，队列也是空的时候，直接return null，并将Worker数量-1
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

           // 注意这里的allowCoreThreadTimeOut参数，字面意思是否允许核心线程超时，即如果我们设置为false，那么只有当线程数wc大于corePoolSize的时候才会超时
           //更直接的意思就是，如果设置allowCoreThreadTimeOut为false，那么线程池在达到corePoolSize个工作线程之前，不会让闲置的工作线程退出
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
          //确认超时，将Worker数-1，然后返回
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                //从队列中取任务，根据timed选择是有时间期限的等待还是无时间期限的等待
                //线程池重复使用线程的原理所在
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

总结：

• 线程池的线程是如何做到复用的。

创建 Thread 对象的时候传入的不是我们的 Runnable 对象，而是通过线程池自定义的 Runnable 类（继承了Runnable 和AQS的worker），这个类主要的作用不仅是执行我们的 Runnable 对象，当我们传入的任务被某个线程执行完毕之后，它还会遍历阻塞队列中其他未执行的任务，这样就能达到一个线程执行多个 Runnable 对象的效果，这个就是线程池复用线程的原理。

• 线程池是如何做到高效并发的。
  看整个线程池的工作流程，有以下几个需要特别关注的并发点.
  ①: 线程池状态和工作线程数量的变更。这个由一个AtomicInteger变量 ctl来解决原子性问题。
  ②: 向工作Worker容器workers中添加新的Worker的时候。这个线程池本身已经加锁了。
  ③: 工作线程Worker从等待队列中取任务的时候。这个由工作队列本身来保证线程安全，比如LinkedBlockingQueue等。

本文参考：https://www.jianshu.com/p/9a8c81066201