线程池源码实现细节盘点

• 当调用 shutdown() 方法时，线程池的状态会从 RUNNING 到 SHUTDOWN，再到 TIDYING，最后到 TERMENATED 销毁状态。
• 当调用 shutdownNow() 方法时，线程池的状态会从 RUNNING 到 STOP，再到 TIDYING，最后到 TERMENATED 销毁状态。

线程池流程

public void execute(Runnable command) {
int c = ctl.get();
// 1. 获取当前线程池的线程数，如果小于核心线程数，创建核心线程 `addWorker(command, true)`
// 只要工作线程数小于核心线程数，不管工作线程是否有空，都会直接创建工作线程并直接任务。
if (workerCountOf(c) < corePoolSize) {
     if (addWorker(command, true))
}
// 2.如果当前线程池是运行状态并且工作线程数量大于等于核心线程数，把任务添加到队列
if (isRunning(c) && workQueue.offer(command)) {
     int recheck = ctl.get();
            // 4.如果当前线程池没有在运行(线程池调用shutdown()方法了)，直接清除任务并执行拒绝策略
        if (! isRunning(recheck) && remove(command))
                reject(command);
            //  5.否则如果线程池在运行并且工作线程数量为0，则创建非核心线程(比如 corePoolSize设置为0的时候，会走这里直接创建非核心线程)
        else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
}
// 3.
// 第一（isRunning(c)==false）: 那么addWorker() 会返回 false 直接执行拒绝策略
// 第二 (workQueue.offer()==false): 那么说明队列满了，这个时候 addWorker() 会返回 true
// 当队列满的时候，会直接addWorker(command,false)创建非核心线程并把任务传给它直接执行。
 else if (!addWorker(command, false))
            reject(command);
}

reject拒绝策略触发时机

• 1.线程池满了，任务队列满了会触发拒绝策略。
• 2.当线程池在调用shutdown方法的时候，如果继续添加任务也会触发拒绝策略。

private boolean addWorker(Runnable firstTask, boolean core) {
		.......
		wc >= (core ? corePoolSize : maximumPoolSize))
		......
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
        // 1. 创建Worker 线程，这里注意点：在Worker里面的线程是通过我们最开始传入的线程工厂创建的
            w = new Worker(firstTask);
            final Thread t = w.thread;
			...
                        workers.add(w);
				......
                if (workerAdded) {
                // 2. 启动线程, 这里的start() 就是线程启动，我们看Worker类里面把this传递给thread了
                    t.start();
                    workerStarted = true;
                }
            }
        } 
        ......
        return workerStarted;
    }

线程池利用了AQS对执行任务进行加锁操作

private final class Worker extends AbstractQueuedSynchronizer implements Runnable
    // Worker类的构造方法, 并且Worker是 实现的 Runnable接口
    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
        // 通过线程工厂创建线程
        this.thread = getThreadFactory().newThread(this);
    }
   // 3. 接着上面第2步 start() 方法过来
   public void run() {
      runWorker(this);
  }
   final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
       // 4. 拿到真正的任务
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
           // 5. 这里如果task为null, 就从 队列里面循环获取，这里就是通过 getTask() 来获取的
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // 这里相应线程中断，或者线程停止
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    try {
                       // 6. 启动任务
                        task.run();
                    } catch (Throwable ex) {
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.unlock();
                }
            }
           // 工作线程中断或者异常跳出，会触发Worker线程回收工作
            completedAbruptly = false;
        } finally {
           // 释放Worker线程
            processWorkerExit(w, completedAbruptly);
        }
    }
}

private Runnable getTask() {
		//超时标志
        boolean timedOut = false; // Did the last poll() time out?
		// 循环
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
			//1. 线程池状态为 SHUTDOWN并且队列为空或者STOP的时候会返回 null, 释放当前线程
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
				...
                return null;
            }
			// 2. 获取当前线程池中线程的数量
            int wc = workerCountOf(c);

            // 3. 当允许核心线程超时或者 当前线程数量大于核心线程数时 timed = true
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
			// 4. timed == true 并且 timeOut == true 并且 队列任务为空且线程池线程存在的情况下，返回null, 释放当前线程
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
            // 5. 从队列里面取值并加了个 keepAliveTime 超时时间，
            //如果超过这个时间还没取到任务，就timedOut=true, 
            //然后再次循环的时候，上面第4步的if 条件就满足了，就会return null,
            // 然后就会释放线程了
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

allowCoreThreadTimeOut这个参数来控制是否能释放核心线程数