多线程之线程池ThreadPoolExecutor 源码解析

整体

public class ThreadPoolExecutor extends AbstractExecutorService
public abstract class AbstractExecutorService implements ExecutorService
public interface ExecutorService extends Executor
public interface Executor 

属性

// 高三位 表示线程状态 除去高三位后的表示 线程数量
	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//  表示在 ctl 中低COUNT_BITS 是用于存放线程数量的位
	private static final int COUNT_BITS = Integer.SIZE - 3;
//COUNT_BITS 最大表示数位
	private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
// 线程状态 运行 111 000000000000000000 
	private static final int RUNNING    = -1 << COUNT_BITS;
// 000 000000000000000
	private static final int SHUTDOWN   =  0 << COUNT_BITS;
// 001 000000000000000
	private static final int STOP       =  1 << COUNT_BITS;
// 010 000000000000000
	private static final int TIDYING    =  2 << COUNT_BITS;
// 011 000000000000000
	private static final int TERMINATED =  3 << COUNT_BITS;
	// 阻塞队列 当线程池中达到核心线程数量时 就会提交到workQueue中
	private final BlockingQueue<Runnable> workQueue;
	// 全局锁
	private final ReentrantLock mainLock = new ReentrantLock();
	// 真正存放worker的地方
	private final HashSet<Worker> workers = new HashSet<>();
	// 当外部线程调用 awaitTermination() 时 外部线程会等待当前线程池状态为 Termination为止
    // 就是 让外部线程封装成waitNode 放入到Condition 队列中 waitNode.thread 就会park
    // 当线程池状态变为 Termination时 会唤醒这些线程 这些线程会进入阻塞队列， 然后去抢占minLock
    // 抢占到 就继续执行
	private final Condition termination = mainLock.newCondition();
	// 生命周期内 最大线程数目
	private int largestPoolSize;
	// 任务完成总数
	private long completedTaskCount;
	// 线程工厂
	private volatile ThreadFactory threadFactory;
	// 拒绝策略
	private volatile RejectedExecutionHandler handler;
	//空闲线程存活时间
	private volatile long keepAliveTime;
	// 控制核心线程数量内的线程 是否可用被回收 true 可用
	private volatile boolean allowCoreThreadTimeOut;
	// 核心线程数量限制
	private volatile int corePoolSize;
	// 最大线程数
	private volatile int maximumPoolSize;

内部类 Worker

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        private static final long serialVersionUID = 6138294804551838833L;

        // 工作线程
        final Thread thread;
        // 最先的开始执行的任务 如果不为null的话
        Runnable firstTask;
        // 完成了多少个任务
        volatile long completedTasks;

     	
        Worker(Runnable firstTask) {
        	// AQS 启动独占模式 为初始中状态 这个不能被抢占锁
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
             // 使用线程工厂创建一个线程，并且将当前worker 指定为runnable 会从run为入口
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker. */
        public void run() {
        // threadPoolExecutor ->runWorker() 这个核心方法
            runWorker(this);
        }

        // 判断当前 worker的独占锁是否被独占
        // 0 表示未被占用
        // 1 表示已被占用
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
        // 尝试去占用worker 的独占锁
        // 表示是否抢占成功
        protected boolean tryAcquire(int unused) {
        	// 使用cas 修改aqs中的state 期望值为0 表示未占用
            // true 表示抢占成功，设置ExclusiveOwnerThread 为当前线程
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
		// 加锁  但是 加锁失败 会阻塞当前线程,知道获取到锁
        public void lock()        { acquire(1); }
        // 尝试加锁 如果锁是未持有状态 加锁成功就返回true 否者就不会阻塞 返回false
        public boolean tryLock()  { return tryAcquire(1); }
        // 一般情况下 调用unlock 要保证当前线程持有锁
        // 特殊情况 当worker的state ==-1  调用初始化 state==1
        // 启动worker
        public void unlock()      { release(1); }
        // 返回worker的lock 是否被占用
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

execute 方法

    // command 可以是 runnable 实现类 也可以是 futureTask
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get(); // 获取最新的ctl值
        // 如果worker的数量小于核心线程数 
        if (workerCountOf(c) < corePoolSize) { 
			// 增加一个worker 提交command任务 并且用核心线程数量作为限制
            if (addWorker(command, true))
                return;
            // 走到这里 说明 增加worker 失败了 
            // 1. 存在并发现象，execute 方法是可能有多个线程同时调用的， 当workerCountOf< corePoolSize 成立
            // 可能其他线程也成立了，并且创立的worker 这时核心线程数量已经达到
            // 2 当前线程状态已经发生改变     // RNNING < SHUTDOWN < STOP < tidying < TERMINATED
            // 当前线程池的状态不是running状态时 addworker 一定会失败
            // shutDown 状态下 也有可能出创建成功
            c = ctl.get(); 
        }
        // 前置条件 工作线程已经达到核心线程数量
        // 判断是不是运行状态 然后尝试添加任务
        
        if (isRunning(c) && workQueue.offer(command)) {
        	// offer任务提交成功了
        	// 再次获取线程池状态
            int recheck = ctl.get();
            // 如果不是运行状态 && 移除command 任务
             // remove(command) 有可能成功 有可能失败
            // 成功 提交之后线程池的线程还未消费
            // 失败 提交之后 在shutdown() 之前就被线程池中的线程给处理了
            if (! isRunning(recheck) && remove(command))
            	  // 提交之后线程状态非running 切 任务出队成功 走拒绝策略
                reject(command);
            // 说明 是运行状态 
            // 说明 线程池是非running 但是remove提交的任务失败
            // 担保机制 保证一定有一个线程工作
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //走到这里
        // 1. 不是运行状态
        // 2 offer失败
        //		2.1 说明 可能当前Queue 已经满了 当前线程数量还有达到最大线程数量 尝试创建新的线程来执行Task
        // 假设当前线程池 数量达到最大 这里也会失败 走拒绝策略
        // 线程池不是running状态 这个时候因为command！=null  addWorer一定是false
        else if (!addWorker(command, false))
            reject(command);
    }

addWorker

private boolean addWorker(Runnable firstTask, boolean core) {
		// 自旋
		// 判断当前线程池是否允许创建新的线程
        retry:
        for (int c = ctl.get();;) {
           // c 是最新的 Ctl值 
          // 判断当前线程状态 是不是>=SHUTDOWN  
            if (runStateAtLeast(c, SHUTDOWN)&& 
            	// 判firstTask 不是空 工作队列不为空
                 (runStateAtLeast(c, STOP)|| firstTask != null || workQueue.isEmpty())
                )
                //线程池状态 rs> shutdown
                // rs = shutdown 但是队列已经没有任务了
                return false;
			// 自旋
			// 获取令牌的过程
            for (;;) {
            	
                if (workerCountOf(c) // 线程数量 是不是大于 限制条件
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    // 如果大于 说明无法添加新线程了
                    return false;
                 // 通过cas的 让workerCount 增加1
                if (compareAndIncrementWorkerCount(c))
               // 线程计数已经成功了 已经申请了一个令牌了
                    break retry;
                c = ctl.get();  // 再次获取 ctl 的最新值
                // 判断当前线程池是否发生过变化，如果外部再次之前调用shutdown 就会失败
                if (runStateAtLeast(c, SHUTDOWN)) 
                // 状态发生变化后 直接返回到外部循环
                    continue retry;
              
            }
        }
		// 当前创建的worker 是否已经启动
        boolean workerStarted = false;
       // 当前创建的worker 是否已经添加到池子
        boolean workerAdded = false;
        // worker 的引用
        Worker w = null;
        try {
            // 创建worker 线程已经创建好了
            w = new Worker(firstTask);
            // 新创建的worker的线程
            final Thread t = w.thread;
            //为了防止ThreadFactory 实现类有bug
            if (t != null) {
                // 将全局锁的引用 给mainLock
                final ReentrantLock mainLock = this.mainLock;
                // 持有全局锁 会阻塞 直到获取成功 同一时刻操纵线程吃内部相关操作都必须持有锁

                mainLock.lock();
                try {
                    // 再次获取最新的线程池运行状态
                    int c = ctl.get();
                    // 判断是否是running  判断当前状态是否小于stop 并且 firstTASK等于null
                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && firstTask == null)) {
                        // t.isAlive() 当线程start后 线程isAlive 会返回true
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        // 将创建的worker 添加到线程池中
                        workers.add(w);
                        // 获取最新的线程数量
                        int s = workers.size();
                        // 说明线程数量是一个新高，更新largestPoolSize
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        // 更新线程增加状态 添加到线程池了
                        workerAdded = true;
                    }
                } finally {
                    //释放全局锁
                    mainLock.unlock();
                }
                // 条件成功 说明添加成功 就start
                // s失败 就是lock之前就发生失败了
                if (workerAdded) {
                    // 启动线程
                    t.start();
                    // 启动标记设置为true
                    workerStarted = true;
                }
            }
        } finally {
            // 说明添加失败 需要清理工作
            if (! workerStarted)
                // 清理工作 释放令牌
                addWorkerFailed(w);
        }
        // 返回新创建的线程是否启动
        return workerStarted;
    }

runWorker

 // w 就是启动的worker
    final void runWorker(Worker w) {
        // wt 就是w.thread
        Thread wt = Thread.currentThread();
        // 初始执行task 复制给task
        Runnable task = w.firstTask;
        w.firstTask = null; // 清空引用
        //  为了初始化worker state
        w.unlock(); // allow interrupts
        // 是否突然退出 ture 发生异常了 需要做处理
        boolean completedAbruptly = true;
        try {
            // firstTask 不是null 直接执行
            // 说明当前线程在queue中获取任务成功，getTask这个方法是一个会阻塞方法
            // 如果返回null 说明当前线程需要退出逻辑
            while (task != null || (task = getTask()) != null) {
                // 加锁 独占锁
                // 就是怕shutdown时 会判断worker状态 根据独占锁是否空闲 ，判断worker 是否工作
                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
                // (runStateAtLeast(ctl.get(), STOP) 判断当前状态是不是大于stop 状态
                // 条件1 :说明线程池是不是出于 stop 或者 tidying或者termintion 此时线程一定要给他一个中断信号
                //  成立 说明当前线程池的状态 是>=stop 且当前线程是未设置中断状态 此时尝试中断。

                // 条件2 :(Thread.interrupted() &&
                //    runStateAtLeast(ctl.get(), STOP)))
                // 获取当前中断状态，且设置中断为false === 大概率还是false
                // 尝试刷新当前线程的中断标记 false 有可能上一次执行task 时 ，
                // 业务代码里面将当前线程的中断标记位设置为true 且没有处理

                //
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();

                try {
                    // 钩子方法 留给子类实现
                    beforeExecute(wt, task);
                    try {
                        // task 可能是futreTask 也可能是普通的runnable接口实现类
                        // 如果是通过submit 提交 可以封装成futreTask
                        task.run();
                        // 钩子方法
                        afterExecute(task, null);
                    } catch (Throwable ex) {
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    // 将局部数量task 设置为null
                    task = null;
                    // 更新worker 完成任务数量
                    w.completedTasks++;
                    // worker 工作完 会释放独占锁
                    // 再次回到getTask() 获取任务
                    // task,run() 发生内部异常
                    w.unlock();
                }
            }

            // getTask() 方法返回null时，说明当前线程应该执行退出逻辑
            completedAbruptly = false;
        } finally {
            //正常退出 completedAbruptly = false
            // 异常退出 completedAbruptly= true
            processWorkerExit(w, completedAbruptly);
        }
    }

getTask()

private Runnable getTask() {
        // 当前任务线程获取任务是否超时 false true 超时
        boolean timedOut = false; // Did the last poll() time out?
        // 自旋
        for (;;) {
            // 获取最新的ctl  高三位 线程状态
            int c = ctl.get();

            // 判断当前状态是不是大于 shutdown
            //(runStateAtLeast(c, STOP) || workQueue.isEmpty())
            // 1 c 的状态是不是>=stop  最低也是stop状态了 一定返回null
            // 2     // RNNING < SHUTDOWN < STOP < tidying < TERMINATED
            // 说明当前条件是 shutdown状态 说明任务队列空了 就返回null
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
                // 计数-1 ctl
                decrementWorkerCount();
                return null;
            }

            // 执行到这
            // 1. 线程池是running
            // 2 线程池是 shutdown 但是任务队列还有任务

            // 获取线程池的线程数量
            int wc = workerCountOf(c);

            // Are workers subject to culling?
            // timed == true 支持超时机制 使用queue.poll 当获取task超时的情况下 下一次自旋可能返回null
            // timed == false 表示不支持超时机制，当前线程会使用queue.task();

            // 情况1  allowCoreThreadTimeOut==true 所有线程都可以被回收
            // 情况2  allowCoreThreadTimeOut == false 核心线程池会维护一个核心线程数
            // wc > corePoolSize 线程池中线程数量是大于核心线程的 就会返回null

            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            //(wc > maximumPoolSize || (timed && timedOut))
            // 成立 外部线程改变最大线程数量
            // 使用poll 获取任务的方式 超时了
            // (wc > 1 || workQueue.isEmpty()))
            // 说明当前线程池 还有其他线程 当前线程可以直接去回收
            // 只有最后一个线程了 任务队列也为空了 .
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                // 使用cas 将 ctl -1
                // 成功返回null
                // 其他线程先一步退出了 线程池状态发生改变了
                if (compareAndDecrementWorkerCount(c))
                    return null;
                // 在此自旋时 timed 可能是false了
                continue;
            }

            try {
                // 获取任务
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                // 返回任务
                if (r != null)
                    return r;
                // 超时了
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

tryTerminate

final void tryTerminate() {
        // 自旋
        for (;;) {
            int c = ctl.get();
            // 如果是running状态 线程很正常
            // runStateAtLeast(c, TIDYING)说明其他任务正在执行 设置tidying
            // (runStateLessThan(c, STOP) && ! workQueue.isEmpty())
            // 如果当前线程小于stop 只能是shutdown状态 并且任务队列不为空
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
                return;
            // 线程状态> = stop
            // 线程池状态 为shutdown 队列为空
            // 当前线程数 不等于0
            if (workerCountOf(c) != 0) { // Eligible to terminate
                // 中断一个空闲线程
                // 唤醒线程会在getTask() 返回null
                // 执行退出逻辑会在会再次调用tryTerminate唤醒下一个线程
                // 最终所有空闲线程都会在这里正常退出
                // 非空闲线程在执行玩task 后 也会执行tryTerminate方法
                interruptIdleWorkers(ONLY_ONE);
                return;
            }

            // 最后一个退出的线程  >=STOP == ShutDown queue ==NULL
            // 0表示最后一个线程了
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                // 设置线程池状态为TiDying
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        //钩子方法
                        terminated();
                    } finally {
                        //线程池状态设置为  TERMINATED
                        ctl.set(ctlOf(TERMINATED, 0));
                        // 唤醒调用awaitTermination()方法的线程
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }

interruptIdleWorkers

  // onlyOne == true 说明中断1 个线程 否则中断多个
    // worker 是控线的
    private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                // 获取当前所有的thread
                Thread t = w.thread;
                // 条件成立 说明t线程 尚未中断过，
                // 说明worker出于空闲状态 可以给一个中断信号

                if (!t.isInterrupted() && w.tryLock()) {

                    try {
                        // 中断信号 处于阻塞状态的线程就会唤醒
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

processWorkerExit

    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        // completedAbruptly==true 这个w 是异常退出的
        if (completedAbruptly)
            // 通过cas -1
            decrementWorkerCount();
        // 获取全局锁
        final ReentrantLock mainLock = this.mainLock;
        //加锁
        mainLock.lock();
        try {
            // 当前线程完成task 的数量 汇总到线程池的completedTaskCount
            completedTaskCount += w.completedTasks;
            // 移除 worker
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }

        tryTerminate();
        // 获取最新的ctl 值
        int c = ctl.get();
        // 当前状态是running
        if (runStateLessThan(c, STOP)) {
            // 正常退出
            if (!completedAbruptly) {
                // min 表示最低持有的线程数量  allowCoreThreadTimeOut == true 说明核心线程数的线程也可以被回收

                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                // 假设min= 0 判断队列不是空 最起码要留一个线程
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                // 条件成立 说明 线程池还拥有足够多的线程
                // 考虑 workerCountOf(c) > min (0>=0)?
                // 当前线程池中的核心线程数 是可以被回收的，这种情况当前线程池中的线程数 会变成0
                // 下次提交任务 会创建线程.
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            // 执行task 线程异常退出
            //  一定要创建一个新worker顶上去，
            // 当前任务不是空的， qu最起码要留一个线程 running|| shutdown
            // sc < 核心线程数 会维护有核心线程数个。
            addWorker(null, false);
        }
    }