Java 线程池 实现原理与源码深度解析
正文java
史上最清晰的线程池源码分析数组
鼎鼎大名的线程池。不须要多说!!!!!架构
这篇博客深刻分析 Java 中线程池的实现。ide
总览
下图是 java 线程池几个相关类的继承结构：工具
先简单说说这个继承结构，Executor 位于最顶层，也是最简单的，就一个 execute(Runnable runnable) 接口方法定义。oop
ExecutorService 也是接口，在 Executor 接口的基础上添加了不少的接口方法，因此通常来讲咱们会使用这个接口。源码分析
而后再下来一层是 AbstractExecutorService，从名字咱们就知道，这是抽象类，这里实现了很是有用的一些方法供子类直接使用，以后咱们再细说。学习
而后才到咱们的重点部分 ThreadPoolExecutor 类，这个类提供了关于线程池所需的很是丰富的功能。this
线程池中的 BlockingQueue 也是很是重要的概念，若是线程数达到 corePoolSize，咱们的每一个任务会提交到等待队列中，等待线程池中的线程来取任务并执行。这里的 BlockingQueue 一般咱们使用其实现类 LinkedBlockingQueue、ArrayBlockingQueue 和 SynchronousQueue，每一个实现类都有不一样的特征，使用场景以后会慢慢分析。想要详细了解各个 BlockingQueue 的读者，能够参考个人前面的一篇对 BlockingQueue 的各个实现类进行详细分析的文章。spa
使用示例
1 package main.java.Juc;
2
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5
6 class MyRunnable implements Runnable {
7 @Override
8 public void run() {
9 for (int x = 0; x < 100; x++) {
10 System.out.println(Thread.currentThread().getName() + ":" + x);
11 }
12 }
13 }
14
15 public class TestThreadPool {
16 public static void main(String[] args) {
17 // 建立一个线程池对象，控制要建立几个线程对象。
18 ExecutorService pool = Executors.newFixedThreadPool(2);
19
20 // 能够执行Runnable对象或者Callable对象表明的线程
21 pool.execute(new MyRunnable());
22 pool.execute(new MyRunnable());
23
24 //结束线程池
25 pool.shutdown();
26 }
27 }
运行结果：
Executor 接口
1 public interface Executor {
2 void execute(Runnable command);
3 }
咱们能够看到 Executor 接口很是简单，就一个 void execute(Runnable command) 方法，表明提交一个任务。
固然了，Executor 这个接口只有提交任务的功能，太简单了，咱们想要更丰富的功能，好比咱们想知道执行结果、咱们想知道当前线程池有多少个线程活着、已经完成了多少任务等等，这些都是这个接口的不足的地方。接下来咱们要介绍的是继承自 Executor 接口的 ExecutorService 接口，这个接口提供了比较丰富的功能，也是咱们最常使用到的接口。
ExecutorService
那么咱们简单初略地来看一下这个接口中都有哪些方法：
1 public interface ExecutorService extends Executor {
2
3 // 关闭线程池，已提交的任务继续执行，不接受继续提交新任务
4 void shutdown();
5
6 // 关闭线程池，尝试中止正在执行的全部任务，不接受继续提交新任务
7 // 它和前面的方法相比，加了一个单词“now”，区别在于它会去中止当前正在进行的任务
8 List<Runnable> shutdownNow();
9
10 // 线程池是否已关闭
11 boolean isShutdown();
12
13 // 若是调用了 shutdown() 或 shutdownNow() 方法后，全部任务结束了，那么返回true
14 // 这个方法必须在调用shutdown或shutdownNow方法以后调用才会返回true
15 boolean isTerminated();
16
17 // 等待全部任务完成，并设置超时时间
18 // 咱们这么理解，实际应用中是，先调用 shutdown 或 shutdownNow，
19 // 而后再调这个方法等待全部的线程真正地完成，返回值意味着有没有超时
20 boolean awaitTermination(long timeout, TimeUnit unit)
21 throws InterruptedException;
22
23 // 提交一个 Callable 任务
24 <T> Future<T> submit(Callable<T> task);
25
26 // 提交一个 Runnable 任务，第二个参数将会放到 Future 中，做为返回值，
27 // 由于 Runnable 的 run 方法自己并不返回任何东西
28 <T> Future<T> submit(Runnable task, T result);
29
30 // 提交一个 Runnable 任务
31 Future<?> submit(Runnable task);
32
33 ......
34 }
这些方法都很好理解，一个简单的线程池主要就是这些功能，能提交任务，能获取结果，能关闭线程池，这也是为何咱们常常用这个接口的缘由。
AbstractExecutorService
AbstractExecutorService 抽象类派生自 ExecutorService 接口，而后在其基础上实现了几个实用的方法，这些方法提供给子类进行调用。
这个抽象类实现了 ExecutorService 中的 submit 方法，newTaskFor 方法用于将任务包装成 FutureTask。定义于最上层接口 Executor中的 void execute(Runnable command) 因为不须要获取结果，不会进行 FutureTask 的包装。
1 public abstract class AbstractExecutorService implements ExecutorService {
2
3 // RunnableFuture 是用于获取执行结果的，咱们经常使用它的子类 FutureTask
4 // 下面两个 newTaskFor 方法用于将咱们的任务包装成 FutureTask 提交到线程池中执行
5 protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
6 return new FutureTask<T>(runnable, value);
7 }
8
9 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
10 return new FutureTask<T>(callable);
11 }
12
13 // 提交任务
14 public Future<?> submit(Runnable task) {
15 if (task == null) throw new NullPointerException();
16 // 1. 将任务包装成 FutureTask
17 RunnableFuture<Void> ftask = newTaskFor(task, null);
18 // 2. 交给执行器执行，execute 方法由具体的子类来实现
19 // 前面也说了，FutureTask 间接实现了Runnable 接口。
20 execute(ftask);
21 return ftask;
22 }
23
24 public <T> Future<T> submit(Runnable task, T result) {
25 if (task == null) throw new NullPointerException();
26 // 1. 将任务包装成 FutureTask
27 RunnableFuture<T> ftask = newTaskFor(task, result);
28 // 2. 交给执行器执行
29 execute(ftask);
30 return ftask;
31 }
32
33 public <T> Future<T> submit(Callable<T> task) {
34 if (task == null) throw new NullPointerException();
35 // 1. 将任务包装成 FutureTask
36 RunnableFuture<T> ftask = newTaskFor(task);
37 // 2. 交给执行器执行
38 execute(ftask);
39 return ftask;
40 }
41 }
到这里，咱们发现，这个抽象类包装了一些基本的方法，但是 submit等方法，它们都没有真正开启线程来执行任务，它们都只是在方法内部调用了 execute 方法，因此最重要的 execute(Runnable runnable) 方法还没出现，这里咱们要说的就是 ThreadPoolExecutor 类了。
ThreadPoolExecutor
咱们常常会使用 Executors 这个工具类来快速构造一个线程池，对于初学者而言，这种工具类是颇有用的，开发者不须要关注太多的细节，只要知道本身须要一个线程池，仅仅提供必需的参数就能够了，其余参数都采用做者提供的默认值。
1 public static ExecutorService newFixedThreadPool(int nThreads) {
2 return new ThreadPoolExecutor(nThreads, nThreads,
3 0L, TimeUnit.MILLISECONDS,
4 new LinkedBlockingQueue<Runnable>());
5 }
6 public static ExecutorService newCachedThreadPool() {
7 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
8 60L, TimeUnit.SECONDS,
9 new SynchronousQueue<Runnable>());
10 }
这里先不说有什么区别，它们最终都会导向这个构造方法：
1 public ThreadPoolExecutor(int corePoolSize,
2 int maximumPoolSize,
3 long keepAliveTime,
4 TimeUnit unit,
5 BlockingQueue<Runnable> workQueue,
6 ThreadFactory threadFactory,
7 RejectedExecutionHandler handler) {
8 if (corePoolSize < 0 ||
9 maximumPoolSize <= 0 ||
10 maximumPoolSize < corePoolSize ||
11 keepAliveTime < 0)
12 throw new IllegalArgumentException();
13 // 这几个参数都是必需要有的
14 if (workQueue == null || threadFactory == null || handler == null)
15 throw new NullPointerException();
16
17 this.corePoolSize = corePoolSize;
18 this.maximumPoolSize = maximumPoolSize;
19 this.workQueue = workQueue;
20 this.keepAliveTime = unit.toNanos(keepAliveTime);
21 this.threadFactory = threadFactory;
22 this.handler = handler;
23 }
上面的构造方法中列出了咱们最须要关心的几个属性了，下面逐个介绍下构造方法中出现的这几个属性：
- corePoolSize
线程池中的核心线程数。
- maximumPoolSize
最大线程数，线程池容许建立的最大线程数。若是当前阻塞队列满了，且继续提交任务，则建立新的线程执行任务，前提是当前线程数小于maximumPoolSize；当阻塞队列是无界队列, 则maximumPoolSize则不起做用, 由于没法提交至核心线程池的线程会一直持续地放入workQueue
- workQueue
用来保存等待被执行的任务的阻塞队列. 在JDK中提供了以下阻塞队列：
(1) ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；
(2) LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量一般要高于ArrayBlockingQuene；
(3) SynchronousQuene：一个不存储元素的阻塞队列，每一个插入操做必须等到另外一个线程调用移除操做，不然插入操做一直处于阻塞状态，吞吐量一般要高于LinkedBlockingQuene；
(4) priorityBlockingQuene：具备优先级的无界阻塞队列；
有兴趣的能够看看我前面关于BlockingQuene的文章
- keepAliveTime
空闲线程的保活时间，若是某线程的空闲时间超过这个值都没有任务给它作，那么能够被关闭了。注意这个值并不会对全部线程起做用，若是线程池中的线程数少于等于核心线程数 corePoolSize，那么这些线程不会由于空闲太长时间而被关闭，固然，也能够经过调用 allowCoreThreadTimeOut(true)使核心线程数内的线程也能够被回收；默认状况下，该参数只在线程数大于corePoolSize时才有用, 超过这个时间的空闲线程将被终止。
- unit
keepAliveTime的单位
- threadFactory
用于生成线程，通常咱们能够用默认的就能够了。一般，咱们能够经过它将咱们的线程的名字设置得比较可读一些，如 Message-Thread-1， Message-Thread-2 相似这样。
- handler
线程池的饱和策略，当阻塞队列满了，且没有空闲的工做线程，若是继续提交任务，必须采起一种策略处理该任务，线程池提供了4种策略：
AbortPolicy：直接抛出异常，默认策略；
CallerRunsPolicy：用调用者所在的线程来执行任务；
DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
DiscardPolicy：直接丢弃任务；
固然也能够根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。
除了上面几个属性外，咱们再看看其余重要的属性。
1 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
2
3 // 这里 COUNT_BITS 设置为 29(32-3)，意味着前三位用于存放线程状态，后29位用于存放线程数
4 private static final int COUNT_BITS = Integer.SIZE - 3;
5
6 // 000 11111111111111111111111111111
7 // 这里获得的是 29 个 1，也就是说线程池的最大线程数是 2^29-1=536870911
8 // 以咱们如今计算机的实际状况，这个数量仍是够用的
9 private static final int CAPACITY = (1 << COUNT_BITS) - 1;
10
11 // 咱们说了，线程池的状态存放在高 3 位中
12 // 运算结果为 111跟29个0：111 00000000000000000000000000000
13 private static final int RUNNING = -1 << COUNT_BITS;
14 // 000 00000000000000000000000000000
15 private static final int SHUTDOWN = 0 << COUNT_BITS;
16 // 001 00000000000000000000000000000
17 private static final int STOP = 1 << COUNT_BITS;
18 // 010 00000000000000000000000000000
19 private static final int TIDYING = 2 << COUNT_BITS;
20 // 011 00000000000000000000000000000
21 private static final int TERMINATED = 3 << COUNT_BITS;
22
23 // 将整数 c 的低 29 位修改成 0，就获得了线程池的状态
24 private static int runStateOf(int c) { return c & ~CAPACITY; }
25 // 将整数 c 的高 3 为修改成 0，就获得了线程池中的线程数
26 private static int workerCountOf(int c) { return c & CAPACITY; }
27
28 private static int ctlOf(int rs, int wc) { return rs | wc; }
29
30 private static boolean runStateLessThan(int c, int s) {
31 return c < s;
32 }
33
34 private static boolean runStateAtLeast(int c, int s) {
35 return c >= s;
36 }
37
38 private static boolean isRunning(int c) {
39 return c < SHUTDOWN;
40 }
在这里，介绍下线程池中的各个状态和状态变化的转换过程：
- RUNNING：这个没什么好说的，这是最正常的状态：接受新的任务，处理等待队列中的任务
- SHUTDOWN：不接受新的任务提交，可是会继续处理等待队列中的任务
- STOP：不接受新的任务提交，再也不处理等待队列中的任务，中断正在执行任务的线程
- TIDYING：全部的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()
- TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个
- 在此我向你们推荐一个架构学习交流圈：830478757 帮助突破瓶颈 提高思惟能力
看了这几种状态的介绍，读者大致也能够猜到十之八九的状态转换了，各个状态的转换过程有如下几种：
- RUNNING -> SHUTDOWN：当调用了 shutdown() 后，会发生这个状态转换，这也是最重要的
- (RUNNING or SHUTDOWN) -> STOP：当调用 shutdownNow() 后，会发生这个状态转换，这下要清楚 shutDown() 和 shutDownNow() 的区别了
- SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING
- STOP -> TIDYING：当任务队列清空后，发生这个转换
- TIDYING -> TERMINATED：这个前面说了，当 terminated() 方法结束后
另外，咱们还要看看一个内部类 Worker，由于 Doug Lea 把线程池中的线程包装成了一个个 Worker，翻译成工人，就是线程池中作任务的线程。因此到这里，咱们知道任务是 Runnable（内部叫 task 或 command），线程是 Worker。
1 private final class Worker
2 extends AbstractQueuedSynchronizer
3 implements Runnable{
4 private static final long serialVersionUID = 6138294804551838833L;
5
6 // 这个是真正的线程，任务靠你啦
7 final Thread thread;
8
9 // 前面说了，这里的 Runnable 是任务。为何叫 firstTask？由于在建立线程的时候，若是同时指定了
10 // 这个线程起来之后须要执行的第一个任务，那么第一个任务就是存放在这里的(线程可不止执行这一个任务)
11 // 固然了，也能够为 null，这样线程起来了，本身到任务队列（BlockingQueue）中取任务（getTask 方法）就好了
12 Runnable firstTask;
13
14 // 用于存放此线程彻底的任务数，注意了，这里用了 volatile，保证可见性
15 volatile long completedTasks;
16
17 // Worker 只有这一个构造方法，传入 firstTask，也能够传 null
18 Worker(Runnable firstTask) {
19 setState(-1); // inhibit interrupts until runWorker
20 this.firstTask = firstTask;
21 // 调用 ThreadFactory 来建立一个新的线程,这里建立的线程到时候用来执行任务
22 this.thread = getThreadFactory().newThread(this);
23 }
24
25 // 这里调用了外部类的 runWorker 方法
26 public void run() {
27 runWorker(this);
28 }
29
30 ...
31 }
有了上面的这些基础后，咱们终于能够看看 ThreadPoolExecutor 的 execute 方法了，前面源码分析的时候也说了，各类方法都最终依赖于 execute 方法：
1 public void execute(Runnable command) {
2 if (command == null)
3 throw new NullPointerException();
4
5 // 前面说的那个表示 "线程池状态" 和 "线程数" 的整数
6 int c = ctl.get();
7
8 // 若是当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务，
9 // 建立一个新的线程，并把当前任务 command 做为这个线程的第一个任务(firstTask)
10 if (workerCountOf(c) < corePoolSize) {
11 // 添加任务成功，那么就结束了。提交任务嘛，线程池已经接受了这个任务，这个方法也就能够返回了
12 // 至于执行的结果，到时候会包装到 FutureTask 中。
13 // 这里的true表明当前线程数小于corePoolSize，表示以corePoolSize为线程数界限
14 if (addWorker(command, true))
15 return;
16 c = ctl.get();
17 }
18 // 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了
19 // 若是线程池处于 RUNNING 状态，把这个任务添加到任务队列 workQueue 中
20 if (isRunning(c) && workQueue.offer(command)) {
21 int recheck = ctl.get();
22 // 若是线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，而且执行拒绝策略
23 if (! isRunning(recheck) && remove(command))
24 reject(command);
25 else if (workerCountOf(recheck) == 0)
26 addWorker(null, false);
27 }
28 // 若是 workQueue 队列满了，那么进入到这个分支
29 // 这里的false表明当前线程数大于corePoolSize，表示以 maximumPoolSize 为界建立新的 worker
30 // 若是失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
31 else if (!addWorker(command, false))
32 reject(command);
33 }
咱们能够看看大致的执行流程
这个方法很是重要 addWorker(Runnable firstTask, boolean core) 方法，咱们看看它是怎么建立新的线程的：
1 // 第一个参数是准备提交给这个线程执行的任务，以前说了，能够为 null
2 // 第二个参数为 true 表明使用核心线程数 corePoolSize 做为建立线程的界线，也就说建立这个线程的时候，
3 // 若是线程池中的线程总数已经达到 corePoolSize，那么返回false
4 // 若是是 false，表明使用最大线程数 maximumPoolSize 做为界线，线程池中的线程总数已经达到 maximumPoolSize，那么返回false
5 private boolean addWorker(Runnable firstTask, boolean core) {
6 retry:
7 for (;;) {
8 int c = ctl.get();
9 int rs = runStateOf(c);
10
11 // 若是线程池已关闭，并知足如下条件之一，那么不建立新的 worker：
12 // 1. 线程池状态大于 SHUTDOWN，其实也就是 STOP, TIDYING, 或 TERMINATED
13 // 2. firstTask != null
14 // 3. workQueue.isEmpty()
15 if (rs >= SHUTDOWN &&
16 ! (rs == SHUTDOWN &&
17 firstTask == null &&
18 ! workQueue.isEmpty()))
19 return false;
20
21 for (;;) {
22 int wc = workerCountOf(c);
23 //这里就是经过core参数对当前线程数的判断
24 if (wc >= CAPACITY ||
25 wc >= (core ? corePoolSize : maximumPoolSize))
26 return false;
27 if (compareAndIncrementWorkerCount(c))
28 break retry;
29 c = ctl.get();
30 if (runStateOf(c) != rs)
31 continue retry;
32 // else CAS failed due to workerCount change; retry inner loop
33 }
34 }
35
36 /*
37 * 到这里，咱们认为在当前这个时刻，能够开始建立线程来执行任务了，
38 */
39
40 // worker 是否已经启动
41 boolean workerStarted = false;
42 // 是否已将这个 worker 添加到 workers 这个 HashSet 中
43 boolean workerAdded = false;
44 Worker w = null;
45 try {
46 final ReentrantLock mainLock = this.mainLock;
47 // 把 firstTask 传给 worker 的构造方法
48 w = new Worker(firstTask);
49 // 取 worker 中的线程对象，以前说了，Worker的构造方法会调用 ThreadFactory 来建立一个新的线程
50 final Thread t = w.thread;
51 if (t != null) {
52 // 这个是整个类的全局锁，由于关闭一个线程池须要这个锁，至少我持有锁的期间，线程池不会被关闭
53 mainLock.lock();
54 try {
55
56 int c = ctl.get();
57 int rs = runStateOf(c);
58
59 // 小于 SHUTTDOWN 那就是 RUNNING
60 // 若是等于 SHUTDOWN，前面说了，不接受新的任务，可是会继续执行等待队列中的任务
61 if (rs < SHUTDOWN ||
62 (rs == SHUTDOWN && firstTask == null)) {
63 // worker 里面的 thread 可不能是已经启动的
64 if (t.isAlive())
65 throw new IllegalThreadStateException();
66 // 加到 workers 这个 HashSet 中
67 workers.add(w);
68 int s = workers.size();
69 // largestPoolSize 用于记录 workers 中的个数的最大值
70 // 由于 workers 是不断增长减小的，经过这个值能够知道线程池的大小曾经达到的最大值
71 if (s > largestPoolSize)
72 largestPoolSize = s;
73 workerAdded = true;
74 }
75 } finally {
76 mainLock.unlock();
77 }
78 // 添加成功的话，启动这个线程
79 if (workerAdded) {
80 // 启动线程，最重要的就是这里，下面咱们会讲解如何执行任务
81 t.start();
82 workerStarted = true;
83 }
84 }
85 } finally {
86 // 若是线程没有启动，须要作一些清理工做，如前面 workCount 加了 1，将其减掉
87 if (! workerStarted)
88 addWorkerFailed(w);
89 }
90 // 返回线程是否启动成功
91 return workerStarted;
92 }
上面第81行代码处已经启动了线程，w = new Worker(firstTask); t = w.thread，咱们接着看看Worker这个类
1 private final class Worker
2 extends AbstractQueuedSynchronizer
3 implements Runnable{
4 private static final long serialVersionUID = 6138294804551838833L;
5 final Thread thread;
6 Runnable firstTask;
7 volatile long completedTasks;
8
9 // Worker 只有这一个构造方法，传入 firstTask
10 Worker(Runnable firstTask) {
11 setState(-1); // inhibit interrupts until runWorker
12 this.firstTask = firstTask;
13 // 调用 ThreadFactory 来建立一个新的线程,这里建立的线程到时候用来执行任务
14 // 咱们发现建立线程的时候传入的值是this，咱们知道建立线程能够经过继承Runnable的方法，
15 // Worker继承了Runnable，而且下面重写了run()方法
16 this.thread = getThreadFactory().newThread(this);
17 }
18
19 // 由上面建立线程时传入的this,上面的thread启动后，会执行这里的run()方法，而且此时runWorker传入的也是this
20 public void run() {
21 runWorker(this);
22 }
23 }
继续往下看 runWorker 方法：
1 // 此方法由 worker 线程启动后调用，这里用一个 while 循环来不断地从等待队列中获取任务并执行
2 // 前面说了，worker 在初始化的时候，能够指定 firstTask，那么第一个任务也就能够不须要从队列中获取
3 final void runWorker(Worker w) {
4 Thread wt = Thread.currentThread();
5 // 该线程的第一个任务(若是有的话)
6 Runnable task = w.firstTask;
7 w.firstTask = null;
8 w.unlock(); // allow interrupts
9 boolean completedAbruptly = true;
10 try {
11 // 循环调用 getTask 获取任务
12 while (task != null || (task = getTask()) != null) {
13 w.lock();
14 // 若是线程池状态大于等于 STOP，那么意味着该线程也要中断
15 if ((runStateAtLeast(ctl.get(), STOP) ||
16 (Thread.interrupted() &&
17 runStateAtLeast(ctl.get(), STOP))) &&
18 !wt.isInterrupted())
19 wt.interrupt();
20 try {
21 beforeExecute(wt, task);
22 Throwable thrown = null;
23 try {
24 // 到这里终于能够执行任务了，这里是最重要的，task是什么？是Worker 中的firstTask属性
25 // 也就是上面咱们使用示例里面的 new MyRunnable()实例，这里就是真正的执行run方法里面的代码
26 task.run();
27 } catch (RuntimeException x) {
28 thrown = x; throw x;
29 } catch (Error x) {
30 thrown = x; throw x;
31 } catch (Throwable x) {
32 thrown = x; throw new Error(x);
33 } finally {
34 afterExecute(task, thrown);
35 }
36 } finally {
37 // 一个任务执行完了，这个线程还能够复用，接着去队列中拉取任务执行
38 // 置空 task，准备 getTask 获取下一个任务
39 task = null;
40 // 累加完成的任务数
41 w.completedTasks++;
42 // 释放掉 worker 的独占锁
43 w.unlock();
44 }
45 }
46 completedAbruptly = false;
47 } finally {
48 // 若是到这里，须要执行线程关闭：
49 // 说明 getTask 返回 null，也就是超过corePoolSize的线程过了超时时间尚未获取到任务，也就是说，这个 worker 的使命结束了，执行关闭
50 processWorkerExit(w, completedAbruptly);
51 }
52 }
咱们看看 getTask() 是怎么获取任务的
1 // 此方法有三种可能：
2 // 1. 阻塞直到获取到任务返回。咱们知道，默认 corePoolSize 以内的线程是不会被回收的，
3 // 它们会一直等待任务
4 // 2. 超时退出。keepAliveTime 起做用的时候，也就是若是这么多时间内都没有任务，那么应该执行关闭
5 // 3. 若是发生了如下条件，此方法必须返回 null:
6 // - 池中有大于 maximumPoolSize 个 workers 存在(经过调用 setMaximumPoolSize 进行设置)
7 // - 线程池处于 SHUTDOWN，并且 workQueue 是空的，前面说了，这种再也不接受新的任务
8 // - 线程池处于 STOP，不只不接受新的线程，连 workQueue 中的线程也再也不执行
9 private Runnable getTask() {
10 boolean timedOut = false; // Did the last poll() time out?
11
12 retry:
13 for (;;) {
14 int c = ctl.get();
15 int rs = runStateOf(c);
16 // 两种可能
17 // 1. rs == SHUTDOWN && workQueue.isEmpty()
18 // 2. rs >= STOP
19 if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
20 // CAS 操做，减小工做线程数
21 decrementWorkerCount();
22 return null;
23 }
24
25 boolean timed; // Are workers subject to culling?
26 for (;;) {
27 int wc = workerCountOf(c);
28 // 容许核心线程数内的线程回收，或当前线程数超过了核心线程数，那么有可能发生超时关闭
29 timed = allowCoreThreadTimeOut || wc > corePoolSize;
30 if (wc <= maximumPoolSize && ! (timedOut && timed))
31 break;
32 if (compareAndDecrementWorkerCount(c))
33 return null;
34 c = ctl.get(); // Re-read ctl
35 // compareAndDecrementWorkerCount(c) 失败，线程池中的线程数发生了改变
36 if (runStateOf(c) != rs)
37 continue retry;
38 // else CAS failed due to workerCount change; retry inner loop
39 }
40 // wc <= maximumPoolSize 同时没有超时
41 try {
42 // 到 workQueue 中获取任务
43 // 若是timed=wc > corePoolSize=false,咱们知道核心线程数以内的线程永远不会销毁，则执行workQueue.take();我前面文章中讲过，take()方法是阻塞方法，若是队里中有任务则取到任务，若是没有任务，则一直阻塞在这里知道有任务被唤醒。
44 //若是timed=wc > corePoolSize=true,这里将执行超时策略，poll(keepAliveTime, TimeUnit.NANOSECONDS)会阻塞keepAliveTime这么长时间，没超时就返回任务，超时则返回null.
45 Runnable r = timed ?
46 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
47 workQueue.take();
48 if (r != null)
49 return r;
50 timedOut = true;
51 } catch (InterruptedException retry) {
52 // 若是此 worker 发生了中断，采起的方案是重试
53 // 解释下为何会发生中断，这个读者要去看 setMaximumPoolSize 方法，
54 // 若是开发者将 maximumPoolSize 调小了，致使其小于当前的 workers 数量，
55 // 那么意味着超出的部分线程要被关闭。从新进入 for 循环，天然会有部分线程会返回 null
56 timedOut = false;
57 }
58 }
59 }
到这里，基本上也说完了整个流程，读者这个时候应该回到 execute(Runnable command) 方法，有两种状况会调用 reject(command) 来处理任务，由于按照正常的流程，线程池此时不能接受这个任务，因此须要执行咱们的拒绝策略。接下来，咱们说一说 ThreadPoolExecutor 中的拒绝策略。
1 final void reject(Runnable command) {
2 // 执行拒绝策略
3 handler.rejectedExecution(command, this);
4 }
此处的 handler 咱们须要在构造线程池的时候就传入这个参数，它是 RejectedExecutionHandler 的实例。
RejectedExecutionHandler 在 ThreadPoolExecutor 中有四个已经定义好的实现类可供咱们直接使用，固然，咱们也能够实现本身的策略，不过通常也没有必要。
1 // 只要线程池没有被关闭，那么由提交任务的线程本身来执行这个任务。
2 public static class CallerRunsPolicy implements RejectedExecutionHandler {
3 public CallerRunsPolicy() { }
4 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
5 if (!e.isShutdown()) {
6 r.run();
7 }
8 }
9 }
10
11 // 无论怎样，直接抛出 RejectedExecutionException 异常
12 // 这个是默认的策略，若是咱们构造线程池的时候不传相应的 handler 的话，那就会指定使用这个
在此我向你们推荐一个架构学习交流圈：830478757 帮助突破瓶颈 提高思惟能力
13 public static class AbortPolicy implements RejectedExecutionHandler {
14 public AbortPolicy() { }
15 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
16 throw new RejectedExecutionException("Task " + r.toString() +
17 " rejected from " +
18 e.toString());
19 }
20 }
21
22 // 不作任何处理，直接忽略掉这个任务
23 public static class DiscardPolicy implements RejectedExecutionHandler {
24 public DiscardPolicy() { }
25 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
26 }
27 }
28
29 // 这个相对霸道一点，若是线程池没有被关闭的话，
30 // 把队列队头的任务(也就是等待了最长时间的)直接扔掉，而后提交这个任务到等待队列中
31 public static class DiscardOldestPolicy implements RejectedExecutionHandler {
32 public DiscardOldestPolicy() { }
33 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
34 if (!e.isShutdown()) {
35 e.getQueue().poll();
36 e.execute(r);
37 }
38 }
39 }
到这里，ThreadPoolExecutor 算是分析得差很少了
相关文章
- 1. Java 线程池 实现原理与源码深度解析
- 2. Java线程池实现原理与源码解析(jdk1.8)
- 3. 深刻源码分析Java线程池的实现原理
- 4. 深刻源码分析-线程池的实现原理
- 5. Java 线程池的原理与实现
- 6. 深刻源码分析Java线程池的实现原理(转载)
- 7. 深刻Java源码理解线程池原理
- 8. Java线程池ThreadPoolExecutor深度探索及源码解析
- 9. Java线程池实现原理详解
- 10. 并发编程之 源码剖析 线程池 实现原理
- 更多相关文章...
- • C# 多线程 - C#教程
- • BASE原理与最终一致性 - NoSQL教程
- • Java Agent入门实战（三）-JVM Attach原理与使用
- • Java Agent入门实战（二）-Instrumentation源码概述
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 字节跳动21届秋招运营两轮面试经验分享
- 2. Java 3 年，25K 多吗？
- 3. mysql安装部署
- 4. web前端开发中父链和子链方式实现通信
- 5. 3.1.6 spark体系之分布式计算-scala编程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在线
- 8. 在线画图
- 9. devtools热部署
- 10. 编译和链接
欢迎关注本站公众号,获取更多信息
