线程池的实现原理

// 状态 RUNNING 线程数 = 0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 这里 COUNT_BITS 设置为 29(32-3)，意味着前三位用于存放线程状态，后29位用于存放线程数
private static final int COUNT_BITS = Integer.SIZE - 3;
//最大线程数是 2^29-1=536870911
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
//111 00000000000000000000000000000
private static final int RUNNING    = -1 << COUNT_BITS;
// 000 00000000000000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
// 001 00000000000000000000000000000
private static final int STOP       =  1 << COUNT_BITS;
// 010 00000000000000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS;
// 011 00000000000000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS;

// Packing and unpacking ctl
//将CAPACITY取非后和c进行取与运算，可以得到高3位的值，即线程池的状态
private static int runStateOf(int c)     {
    return c & ~CAPACITY; }
//将c和CAPACITY取与运算，可以得到低29位的值，即线程池的个数
private static int workerCountOf(int c)  {
    return c & CAPACITY; }
private static int ctlOf(int rs, int wc) {
    return rs | wc; }

public void execute(Runnable command) {
   
    if (command == null)
        throw new NullPointerException();

    int c = ctl.get();
      //如果当前的线程数小于corePoolSize
    if (workerCountOf(c) < corePoolSize) {
   
          //调用addWorker新建一个线程
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
       // 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了
      //校验当前线程状态是RUNNING，并将command入队
    if (isRunning(c) && workQueue.offer(command)) {
   
        int recheck = ctl.get();
          //如果不是运行状态，那么移除队列，并执行拒绝策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程
          //防止任务提交到队列中了，但是线程都关闭了
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
      //到这里说明队列已经满了，所以新建一个线程，如果新建的线程数已经超过了maximumPoolSize，那么执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

private boolean addWorker(Runnable firstTask, boolean core) {
   
    retry:
    for (;;) {
   
        int c = ctl.get();
          //获取当前线程池状态
        int rs = runStateOf(c);

        // 1.仅在必要时检查队列是否为空。
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
   
            int wc = workerCountOf(c);
               //2. 校验传入的线程数是否超过了容量大小， 或者是否超过了corePoolSize或maximumPoolSize
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
              //到了这里说明线程数没有超，那么就用CAS将线程池的个数加1
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
              //3 说明有其他的线程抢先更新了状态，继续下一轮的循环，跳到外层循环
            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 {
   
          //创建一个线程
        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());
                  //4 如果线程是没有问题的话，那么将worker加入到队列中
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
   
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize 用于记录 workers 中的个数的最大值
                    // 因为 workers 是不断增加减少的，通过这个值可以知道线程池的大小曾经达到的最大值
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
   
                mainLock.unlock();
            }
               //如果worker入队成功，那么启动线程
            if (workerAdded) {
   
                t.start();
                workerStarted = true;
            }
        }
    } finally {
   
          //如果worker启动失败，那么就回滚woker线程创建的状态
        if (! workerStarted)
            addWorkerFailed(w);
    }
      // 返回线程是否启动成功
    return workerStarted;
}

private void addWorkerFailed(Worker w) {
   
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
   
        if (w != null)
            workers.remove(w);
        decrementWorkerCount();
        tryTerminate();
    } finally {
   
        mainLock.unlock();
    }
}

private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
   

    final Thread thread;
    /** Initial task to run. Possibly null. */
    Runnable firstTask;
    /** Per-thread task counter */
    volatile long completedTasks;

    Worker(Runnable firstTask) {
   
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
      ....
}

public void run() {
   
    runWorker(this);
}

final void runWorker(Worker w) {
   
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
   
          //如果task为空，那么就从workQueue里面获取task
        while (task != null || (task = getTask()) != null) {
   
            w.lock();
              // 如果线程池状态大于等于 STOP，那么意味着该线程也要中断
            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，准备 getTask 获取下一个任务
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
   
          //异常情况或getTask获取不到任务时会执行关闭
        processWorkerExit(w, completedAbruptly);
    }
}

// 为分析而简化后的代码
private Runnable getTask() {
   
    boolean timedOut = false;
    for (;;) {
   
        int c = ctl.get();
        int wc = workerCountOf(c);

        // timed变量用于判断是否需要进行超时控制。
        // allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
        // wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
        // 对于超过核心线程数量的这些线程，需要进行超时控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if (timed && timedOut) {
   
            // 如果需要进行超时控制，且上次从缓存队列中获取任务时发生了超时，那么尝试将workerCount减1,即当前活动线程数减1，
            // 如果减1成功，则返回null，这就意味着runWorker()方法中的while循环会被退出，其对应的线程就要销毁了，也就是线程池中少了一个线程了
            if (compareAndDecrementWorkerCount(c))
            return null;
            continue;
        }

        try {
   
            Runnable r = timed ?
            workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
            workQueue.take();

            // 注意workQueue中的poll()方法与take()方法的区别
            //poll方式取任务的特点是从缓存队列中取任务,最长等待keepAliveTime的时长，取不到返回null
            //take方式取任务的特点是从缓存队列中取任务，若队列为空,则进入阻塞状态，直到能取出对象为止

            if (r != null)
            return r;
            timedOut = true;
            } catch (InterruptedException retry) {
   
                timedOut = false;
        }
    }
}

private void processWorkerExit(Worker w, boolean completedAbruptly) {
   
      //如果是异常原因中断，那么需要将运行线程数减一
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
   
          //设置完成任务数
        completedTaskCount += w.completedTasks;
          //将worker从集合里移除
        workers.remove(w);
    } finally {
   
        mainLock.unlock();
    }
      //判断当前的线程池是否处于SHUTDOWN状态，判断是否要终止线程
    tryTerminate();

    int c = ctl.get();
      //如果是RUNNING或SHUTDOWN则会进入这个方法
    if (runStateLessThan(c, STOP)) {
   
          //如不是以外中断则会往下走
        if (!completedAbruptly) {
   
              //判断是否保留最少核心线程数
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
          //如果当前运行的Worker数比当前所需要的Worker数少的话，那么就会调用addWorker，添加新的Worker
        addWorker(null, false);
    }
}