样例及原理ThreadPoolExecutor executor = new ThreadPoolExecutor( 2, // 核心线程数 4, // 最大线程数 5, TimeUnit.SECONDS, // 最大线程的回收时间 new ArrayBlockingQueue<>(999), // 阻塞队列 (Runnable r, ThreadPoolExecutor executor)->{ // 自定义拒绝策略 });@Testpublic void test(){ executor.execute(()->{ // 交给线程池执行的任务 }); Future<String> future = executor.submit(()->{ // 交给线程池执行的有返回值的任务 return ""; });}execute原理线程池工作流程工作线程数 < 核心线程数，创建线程线程一直处于while循环中（不被释放），首次直接执行任务，之后以take方式获取阻塞队列任务工作线程数 >= 核心线程数，offer方式将任务加入阻塞队列offer成功：什么都不用做，等待队列任务被消费即可offer失败：创建最大线程；最大线程会采用poll+超时时间的方式获取阻塞队列任务；超时未获取到任务，会跳出循环最大线程释放超级变量ctl：记录线程池状态及个数// -- 线程池生命周期的各个状态（COUNT_BITS=29）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;// -- 最高3位标识状态，其余低位表线程个数private final AtomicInteger ctl = new AtomicInteger( // (RUNNING | 0) // 初始值：1110 0000 0000 0000 0000 0000 0000 0000 ctlOf(RUNNING, 0));// 0001 1111 1111 1111 1111 1111 1111 1111private static final int CAPACITY = (1 << COUNT_BITS) - 1;// == 1.获取工作线程数方法，取低29位// 入参c：ctl.get()// 以ctl初始值为例：// 1110 0000 0000 0000 0000 0000 0000 0000 // 0001 1111 1111 1111 1111 1111 1111 1111 (CAPACITY)// &操作结果是0private static int workerCountOf(int c) { return c & CAPACITY; }// == 2.获取状态的方法，取高3位// 入参c：ctl.get()// 以ctl初始值为例：// 1110 0000 0000 0000 0000 0000 0000 0000 // 1110 0000 0000 0000 0000 0000 0000 0000 (~CAPACITY)// &操作结果是RUNNINGprivate static int runStateOf(int c) { return c & ~CAPACITY; }线程池接收任务的核心处理public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); // == 1.小于核心线程数，增加工作线程 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } // == 2.线程池正在运行，且正常添加任务 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); // -- 2.1 线程池处于非运行状态，且任务能从队列中移除：则执行拒绝策略 if (! isRunning(recheck) && remove(command)) reject(command); // -- 2.2 无工作线程，直接创建无任务线程 else if (workerCountOf(recheck) == 0) addWorker(null, false); } // == 3.最大线程创建失败：则执行拒绝策略 else if (!addWorker(command, false)) reject(command);}新增线程做了哪些操作？private boolean addWorker(Runnable firstTask, // -- true：增加核心线程数 // -- false：增加最大线程数 boolean core) { // == 1.判定是否允许新增线程，如果允许则增加线程计数 retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // 线程池状态判定 if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); // ## 线程数判定： // 大于线程允许的最大值，或大于线程参数（根据core，判定核心线程数或最大线程数） // 则返回false if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)){ return false; } // ## 增加线程计数，成功后跳出外层循环 if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; } } // == 2.新增线程，并让线程执行任务 boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { // ## 2.1 创建worker，构造函数中创建线程 w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; // ## 2.2 加锁，向工作线程集合中加入新增的线程 mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); 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(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } // 2.2步骤结束 // ## 2.3 任务开始执行：新增的工作线程执行start方法 if (workerAdded) { t.start(); workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); } return workerStarted;}工作线程如何工作？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 { // ## 循环中 while (task != null // == 1.take方式从阻塞队列里获取任务，如果无任务则阻塞 // 未获取到任务，将跳出循环——意味着本线程释放 || (task = getTask()) != null) { // -- 加锁执行任务（Worker继承了AQS） w.lock(); if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { // 任务执行前的函数，需自定义实现 beforeExecute(wt, task); Throwable thrown = null; try { // == 2.从阻塞队列里获取任务，如果有任务则当前线程执行 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); }}具体的任务获取方法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); // ## 允许核心线程执行任务超时，或者线程数已经超过了核心线程数（已经是最大线程开始执行任务） boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { // 工作线程数递减，比如超时获取任务情况 if (compareAndDecrementWorkerCount(c)) return null; continue; } try { // ## // -- 有超时设置，采用`poll+超时`的方式从阻塞队列获取任务 // 如：最大线程超时未获取到任务，将返回null // -- 无超时设置，采用`take`的方式从阻塞队列获取任务（如果无任务，则阻塞） Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } }}
