简介
ForkJoin 框架，另一种风格的线程池（相比于ThreadPoolExecutor），采用分治算法，工作密取策略，极大地提高了并行性。对于那种大任务分割小任务的场景（分治）尤其有用。
框架图
几个角色
- ForkJoinTask: 有3个实现，分别是RecursiveTask，RecursiveAction，CountedCompleter.
- RecursiveTask: 可以递归执行的ForkJoinTask。
- RecursiveAction: 无返回值的RecursiveTask。
- CountedCompleter: 任务执行完成后，触发执行自定义钩子函数。
- ForkJoinWorkerThread: 运行 ForkJoinTask 任务的工作线程。
- WorkQueue: 任务队列，支持LIFO(last-in-first-out)的push和pop操作（top端），和FIFO(first-in-first-out)的poll操作（base端），队栈二相性。
- WorkQueue[]: ForkJoinPool 中的任务分为两种，一种是本地提交的任务Submission task，通过execute()、submit()、invoke()等方法提交的任务；另外一种是工作线程fork出的子任务Worker task.
两种任务都会存放在WorkQueue数组中，Submission task存放在WorkQueue数组的偶数索引位置，Worker task存放在奇数索引位置。工作线程只会分配在奇数索引的工作队列。
基本算法
1 protected Long compute() {
2 if (end - start <= THRESHOLD) {
3 return justCompute();
4 } else {
5 left.fork();
6 right.fork();
7 return right.join() + left.join();
8 }
9 }
源码解析
数据结构
ForkJoinWorkerThreadFactory
线程工厂接口，用于创建工作线程ForkJoinWorkerThread，默认实现是DefaultForkJoinWorkerThreadFactory.
WorkQueue
work-stealing 模式的双端任务队列（内部是数组实现，ForkJoinTask<?>[] array）。
-
工作线程调用fork()方法将分解的任务入队（栈），处于top端（栈顶），工作线程处理自己工作队列的任务时，从栈顶取任务。
- 工作线程也会窃取别的队列的任务，从base端获取。
内部属性
1 static final int INITIAL_QUEUE_CAPACITY = 1 << 13; // 初始队列容量 2 static final int MAXIMUM_QUEUE_CAPACITY = 1 << 26; // 最大队列容量 3 volatile int scanState; // 扫描状态, <0: inactive; 奇数:scanning; 偶数:running 4 int stackPred; // 前任池（WorkQueue[]）索引，由此构成一个栈 5 int nsteals; // 偷取的任务个数 6 int hint; // 记录偷取者的索引 7 int config; // pool index | mode 8 volatile int qlock; // 1: locked, < 0: terminate; else 0 9 volatile int base; // 栈底/队列头 10 int top; // 栈顶/队列尾 11 ForkJoinTask<?>[] array; // 任务数组 12 final ForkJoinPool pool; // the containing pool (may be null) 13 final ForkJoinWorkerThread owner; // 当前工作队列的工作线程，共享模式下为null 14 volatile Thread parker; // 调用park阻塞期间为owner，其他情况为null 15 volatile ForkJoinTask<?> currentJoin; // 记录当前join来的任务 16 volatile ForkJoinTask<?> currentSteal; // 记录从其他工作队列偷取过来的任务
ForkJoinTask
有3个实现，分别是RecursiveTask，RecursiveAction，CountedCompleter.
RecursiveTask: 可以递归执行的ForkJoinTask。
RecursiveAction: 无返回值的RecursiveTask。
CountedCompleter: 任务执行完成后，触发执行自定义钩子函数。
1 volatile int status; // 任务状态 2 static final int DONE_MASK = 0xf0000000; // 任务完成掩码 3 static final int NORMAL = 0xf0000000; // 正常，负数 4 static final int CANCELLED = 0xc0000000; // 取消，< NORMAL 5 static final int EXCEPTIONAL = 0x80000000; // 异常，< CANCELLED 6 static final int SIGNAL = 0x00010000; // 通知状态， >= 1 << 16 7 static final int SMASK = 0x0000ffff; // 低位掩码
EmptyTask
空任务，用于替换队列中join的任务。
前置条件，subTask之前已经通过fork入队（当前线程所属的工作队列/栈）
线程执行当前任务时，碰见subTask.join()，便会去队列里查找subTask，从栈顶开始，如果恰巧栈顶就是subTask，那么直接执行；若是在队列中间找到，我们知道，任务队列内部是数数组（ForkJoinTask<?>[]），所以没法使其他的任务填补这个空缺（若不填补，此位置为null，那么每个任务便多了一个非空判断），所以使用一个EmptyTask填补此位置（当线程拿到这个task时，什么都不用做，因为方法体没内容，索引很快执行下一个任务）。
核心参数
1 static final int SMASK = 0xffff; // 低16位掩码，最大索引位
2 static final int MAX_CAP = 0x7fff; // 工作线程最大容量
3 static final int EVENMASK = 0xfffe; // 偶数低位掩码
4 static final int SQMASK = 0x007e; // 最多64个偶数槽位（0x007e = 0111 1110,有效的是中间6个1的位置，111111 = 63，再加上000000（0槽位），总共64个）
5
6 static final int SCANNING = 1; // 标记正在scan任务
7 static final int INACTIVE = 1 << 31; // 未活动状态
8 static final int SS_SEQ = 1 << 16; // 版本号（防止CAS的ABA问题）
9
10 static final int MODE_MASK = 0xffff << 16; // int高16位掩码
11 static final int LIFO_QUEUE = 0; // LIFO模式
12 static final int FIFO_QUEUE = 1 << 16; // FIFO模式
13 static final int SHARED_QUEUE = 1 << 31; // 共享模式
14
15 public static final ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory; // 线程创建工厂
16
17 private static final RuntimePermission modifyThreadPermission; // 修改（启动或kill）线程所需要的权限
18
19 static final ForkJoinPool common; // 公共线程池
20
21 static final int commonParallelism; // 并行度
22
23 private static int commonMaxSpares; // 备用线程数
24
25 private static int poolNumberSequence; // 线程名称相关
26
27 private static final synchronized int nextPoolId() {
28 return ++poolNumberSequence;
29 }
30
31 private static final long IDLE_TIMEOUT = 2000L * 1000L * 1000L; // 2sec
32
33 private static final long TIMEOUT_SLOP = 20L * 1000L * 1000L; // 20ms
34
35 private static final int DEFAULT_COMMON_MAX_SPARES = 256; // 默认备用线程数
36
37 private static final int SPINS = 0; // 自旋，暂未使用
38
39 private static final int SEED_INCREMENT = 0x9e3779b9; //indexSeed的增量
40
41 private static final long SP_MASK = 0xffffffffL; // 低32位掩码
42 private static final long UC_MASK = ~SP_MASK; // 高32位掩码
43
44 private static final int AC_SHIFT = 48; // 活跃线程shift
45 private static final long AC_UNIT = 0x0001L << AC_SHIFT; // 活跃线程增量单位
46 private static final long AC_MASK = 0xffffL << AC_SHIFT; // 活跃线程掩码
47
48 private static final int TC_SHIFT = 32; // 工作线程shift
49 private static final long TC_UNIT = 0x0001L << TC_SHIFT; // 工作线程增量单位
50 private static final long TC_MASK = 0xffffL << TC_SHIFT; // 工作线程掩码
51 private static final long ADD_WORKER = 0x0001L << (TC_SHIFT + 15); // 创建工作线程的标记
52
53 // 线程池的状态
54 private static final int RSLOCK = 1; // 锁定
55 private static final int RSIGNAL = 1 << 1; // 通知
56 private static final int STARTED = 1 << 2; // 开始
57 private static final int STOP = 1 << 29; // 停止
58 private static final int TERMINATED = 1 << 30; // 终止
59 private static final int SHUTDOWN = 1 << 31; // 关闭
60
61 volatile long ctl; // 主控参数
62 volatile int runState; // 线程池运行状态
63 final int config; // 并行度 | 模式
64 int indexSeed; // 用于生成工作线程索引
65 volatile WorkQueue[] workQueues; // 池
66 final ForkJoinWorkerThreadFactory factory; // 线程工厂
67 final UncaughtExceptionHandler ueh; // 每个工作线程的异常信息
68 final String workerNamePrefix; // 用于创建工作线程的名称
69 volatile AtomicLong stealCounter; // 偷取任务总数，也可作为同步监视器
ctl
字段ctl是ForkJoinPool的核心状态，它是一个64位的long类型数值，包含4个16位子字段:
AC: 活动的工作线程数量减去目标并行度（目标并行度：最大的工作线程数量，所以AC一般是负值，等于0时，说明活动线程已经达到饱和了）
TC: 总的工作线程数量总数减去目标并行度（TC一般也是负值，等于0时，说明总的工作线程已经饱和，并且，AC一般小于等于TC）
SS: 栈顶工作线程状态和版本数（每一个线程在挂起时都会持有前一个等待线程所在工作队列的索引，由此构成一个等待的工作线程栈，栈顶是最新等待的线程，第一位表示状态1.不活动 0.活动，后15表示版本号，标识ID的版本-最后16位）。
ID: 栈顶工作线程所在工作队列的池索引。
这样设计的好处是，通过观察AC或TC的符号（正负）就可以判断（活动|总）工作线程是否达到并行度。令sp = (int)ctl, sp取ctl的后32位，即SS|ID，如果sp非0，则可知有等待的工作线程。
runState
- STARTED 1
- STOP 1 << 1
- TERMINATED 1<<2
- SHUTDOWN 1<<29
- RSLOCK 1<<30
- RSIGNAL 1<<31
runState记录了线程池的运行状态，特别地，除了SHUTDOWN是负数外，其他值都是正数，RSLOCK和RSIGNAL是跟锁相关。
关键方法
提交任务
execute(ForkJoinTask<?>)/submit(ForkJoinTask<?>)/invoke(ForkJoinTask<?>)
1 public void execute(ForkJoinTask<?> task) { // 只提交任务
2 if (task == null)
3 throw new NullPointerException();
4 externalPush(task);
5 }
6
7 public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task) { // 提交并立刻返回任务，ForkJoinTask实现了Future，支持异步取消等操作
8 if (task == null)
9 throw new NullPointerException();
10 externalPush(task);
11 return task;
12 }
13
14 public <T> T invoke(ForkJoinTask<T> task) { // 提交任务，并等待返回执行结果
15 if (task == null)
16 throw new NullPointerException();
17 externalPush(task);
18 return task.join();
19 }
这三个方法都调用了externalPush(ForkJoinTask<?> task)方法，均属于外部提交，置于偶数索引工作队列。
externalPush(ForkJoinTask<?> task)
1 final void externalPush(ForkJoinTask<?> task) {
2 WorkQueue[] ws;
3 WorkQueue q;
4 int m;
5 int r = ThreadLocalRandom.getProbe(); // 探针值，用于计算WorkQueue槽位索引
6 int rs = runState;
7 if ((ws = workQueues) != null // 线程池不为空
8 && (m = (ws.length - 1)) >= 0 // 线程池长度大于0
9 && (q = ws[m & r & SQMASK]) != null // 获取偶数槽位的WorkQueue, m & r & SQMASK, m是全1的掩码，r是随机值，SQMASK(0x7E)偶数，与之与也是偶数
10 && r != 0 // 探针值不为0
11 && rs > 0 // 线程池状态大于0，SHUTDOWN < 0
12 && U.compareAndSwapInt(q, QLOCK, 0, 1)) { // 0 -> 1获得锁
13 ForkJoinTask<?>[] a;
14 int am, n, s;
15 if ((a = q.array) != null // 任务队列（数组）不为空
16 && (am = a.length - 1) > (n = (s = q.top) - q.base)) { // 且数组长度大于任务个数，不需要扩容
17 int j = ((am & s) << ASHIFT) + ABASE; // 计算任务索引位置
18 U.putOrderedObject(a, j, task); // 任务入队
19 U.putOrderedInt(q, QTOP, s + 1); // top加1
20 U.putIntVolatile(q, QLOCK, 0); // 1 -> 0解锁
21 if (n <= 1) // 之前任务个数小于等于1（刚巧又被别的线程偷走），那么此槽位上的线程有可能等待，如果大家都没任务，可能都在等待
22 signalWork(ws, q); // 唤醒可能存在的等待线程
23 return;
24 }
25 U.compareAndSwapInt(q, QLOCK, 1, 0); // 任务入队失败，解锁，走完整的添加任务方法
26 }
27 externalSubmit(task); // 如果不满足if条件，则走完整的添加任务方法
28 }
externalSubmit(ForkJoinTask<?> task)
1 private void externalSubmit(ForkJoinTask<?> task) {
2 int r; // 初始化当前线程的探针值，后续用于计算WorkQueue的索引
3 if ((r = ThreadLocalRandom.getProbe()) == 0) {
4 ThreadLocalRandom.localInit();
5 r = ThreadLocalRandom.getProbe();
6 }
7 for (;;) {
8 WorkQueue[] ws;
9 WorkQueue q;
10 int rs, m, k;
11 boolean move = false;
12 if ((rs = runState) < 0) { // 如果线程池已经关闭，则去帮助关闭它
13 tryTerminate(false, false);
14 throw new RejectedExecutionException();
15 } else if ((rs & STARTED) == 0 || ((ws = workQueues) == null || (m = ws.length - 1) < 0)) { // 初始华工作队列池
16 int ns = 0;
17 rs = lockRunState(); // 加锁
18 try {
19 if ((rs & STARTED) == 0) { // 加锁后再次判断线程池的状态，不重复初始化
20 U.compareAndSwapObject(this, STEALCOUNTER, null, new AtomicLong()); // 初始化stealCounter
21 int p = config & SMASK;
22 int n = (p > 1) ? p - 1 : 1; // 保证n是2的幂次方
23 n |= n >>> 1;
24 n |= n >>> 2;
25 n |= n >>> 4;
26 n |= n >>> 8;
27 n |= n >>> 16;
28 n = (n + 1) << 1;
29 workQueues = new WorkQueue[n];
30 ns = STARTED; // 标记已经启动
31 }
32 } finally {
33 unlockRunState(rs, (rs & ~RSLOCK) | ns); // 释放锁
34 }
35 } else if ((q = ws[k = r & m & SQMASK]) != null) { // 获取随机偶数槽位的WorkQueue
36 if (q.qlock == 0 && U.compareAndSwapInt(q, QLOCK, 0, 1)) { // 锁定当前WorkQueue
37 ForkJoinTask<?>[] a = q.array; // 任务队列
38 int s = q.top; // 栈顶/队列尾部
39 boolean submitted = false; // 标记是否成功提交任务
40 try {
41 if ((a != null && a.length > s + 1 - q.base) || (a = q.growArray()) != null) { // 任务队列（a）若为空，growArray()会初始化
42 int j = (((a.length - 1) & s) << ASHIFT) + ABASE; // 计算内存地址
43 U.putOrderedObject(a, j, task); // push任务
44 U.putOrderedInt(q, QTOP, s + 1); // 更新top值
45 submitted = true; // 标记任务提交成功
46 }
47 } finally {
48 U.compareAndSwapInt(q, QLOCK, 1, 0); // 解锁
49 }
50 if (submitted) {
51 signalWork(ws, q); // 唤醒挂起的线程
52 return;
53 }
54 }
55 move = true; // 操作失败，需要换个槽位，更新探针值
56 } else if (((rs = runState) & RSLOCK) == 0) { // q为空，则需要创建工作队列，在线程池没有锁定的情况下进行，不然之前换其他槽位
57 q = new WorkQueue(this, null); // 初始化工作队列
58 q.hint = r; // 记录偷取者的索引，初始为随机值
59 q.config = k | SHARED_QUEUE; // 索引 | 共享模式
60 q.scanState = INACTIVE; // 未激活
61 rs = lockRunState(); // 加锁
62 if (rs > 0 && (ws = workQueues) != null && k < ws.length && ws[k] == null)
63 ws[k] = q; // 将工作队列焊到池的槽位上
64 unlockRunState(rs, rs & ~RSLOCK); // 释放锁
65 } else
66 move = true;
67 if (move) // 更新探针值
68 r = ThreadLocalRandom.advanceProbe(r);
69 }
70 }
包含3部分
- 如果线程池还没初始化，则初始化线程池，长度是2的幂次方，期间需锁定runState
- 如果选中的槽位为空（没有工作队列入驻），则初始桦一个工作队列（共享模式的，因为是外部提交，偶数索引），初始是为激活状态，还没投入使用，设置到池里时需锁定runState
- 如果选中的槽位不为空，则获得任务队列（数组），尝试将任务提交进去，成功则唤醒可能沉睡的线程，并返回，如果失败（可能别的线程抢先一步），则转移槽位。
signalWork(WorkQueue[] ws, WorkQueue q)
1 final void signalWork(WorkQueue[] ws, WorkQueue q) {
2 long c;
3 int sp, i;
4 WorkQueue v;
5 Thread p;
6 while ((c = ctl) < 0L) { // 活跃线程未达到并行度，激活或创建
7 if ((sp = (int) c) == 0) { // 没有空闲的线程
8 if ((c & ADD_WORKER) != 0L) // (c & ADD_WORKER) != 0L，说明TC的最高位为1，为负值，而TC = 总的线程数 - 并行度 < 0，表示总的线程数 < 并行度，说明工作线程的个数还很少
9 tryAddWorker(c); // 尝试添加线程
10 break; // 退出
11 }
12 if (ws == null) // 未开始或已停止
13 break;
14 if (ws.length <= (i = sp & SMASK)) // 空闲线程栈顶端线程的所属工作队列索引（正常来讲，应该小于WorkQueue[]的长度的）
15 break;
16 if ((v = ws[i]) == null) // 正在终止，deregisterWorker方法可使对应槽位置空
17 break;
18 int vs = (sp + SS_SEQ) & ~INACTIVE; // 作为下一个scanState待更新的值（增加了版本号，并且调整为激活状态）
19 int d = sp - v.scanState; // 如果d为0，则说明scanState还为更新过，然后才考虑CAS ctl
20 long nc = (UC_MASK & (c + AC_UNIT)) | (SP_MASK & v.stackPred); // 下一个ctl的值，AC + 1 | 上一个等待线程的索引
21 if (d == 0 && U.compareAndSwapLong(this, CTL, c, nc)) { // CAS ctl
22 v.scanState = vs; // 更新scanState
23 if ((p = v.parker) != null) // 如果线程阻塞了，唤醒它
24 U.unpark(p);
25 break;
26 }
27 if (q != null && q.base == q.top) // 没有任务，直接退出
28 break;
29 }
30 }
创建或唤醒一个工作线程 。
这里有一个疑问
if (ws.length <= (i = sp & SMASK)) 表示已终止，ws的类型是WorkQueue[]，取自workQueues，是一早被初始化的，长度是2的幂次方，后续对它的操作是扩容，但没有对它进行缩减操作，所以这个if语句应该永远不为真，不过，这并不影响理解，也不排除这种情况存在的可能性，也是一种保证，毕竟索引大小不能大于数组长度。
tryAddWorker(long c)
1 private void tryAddWorker(long c) {
2 boolean add = false;
3 do {
4 long nc = ((AC_MASK & (c + AC_UNIT)) | (TC_MASK & (c + TC_UNIT))); // 下一个ctl的值，AC和TC都加1
5 if (ctl == c) { // ctl没被其他线程改变
6 int rs, stop;
7 if ((stop = (rs = lockRunState()) & STOP) == 0) // 检查线程池是否停止
8 add = U.compareAndSwapLong(this, CTL, c, nc); // 更新ctl
9 unlockRunState(rs, rs & ~RSLOCK); // 解锁
10 if (stop != 0) // 已经停止，退出
11 break;
12 if (add) { // 更新ctl成功，创建线程
13 createWorker();
14 break;
15 }
16 }
17 } while (((c = ctl) & ADD_WORKER) != 0L && (int) c == 0); // 重新获取ctl，并且没有达到最大线程数，而且，没有空闲的线程
18 }
createWorker()
1 private boolean createWorker() {
2 ForkJoinWorkerThreadFactory fac = factory;
3 Throwable ex = null;
4 ForkJoinWorkerThread wt = null;
5 try {
6 if (fac != null && (wt = fac.newThread(this)) != null) { // 调用线程工厂创建线程，会去注册线程
7 wt.start(); // 启动线程
8 return true;
9 }
10 } catch (Throwable rex) {
11 ex = rex;
12 }
13 deregisterWorker(wt, ex); // 创建失败，注销线程，更新ctl
14 return false;
15 }
ForkJoinWorkerThread 的构造方法里会调用registerWorker(ForkJoinWorkerThread wt)方法。
registerWorker(ForkJoinWorkerThread wt)
1 final WorkQueue registerWorker(ForkJoinWorkerThread wt) {
2 UncaughtExceptionHandler handler;
3 wt.setDaemon(true); // 设置为守护线程
4 if ((handler = ueh) != null)
5 wt.setUncaughtExceptionHandler(handler);
6 WorkQueue w = new WorkQueue(this, wt); // 创建工作队列
7 int i = 0; // 绑定线程池索引（WorkQueue[]）
8 int mode = config & MODE_MASK;
9 int rs = lockRunState(); // 锁定
10 try {
11 WorkQueue[] ws;
12 int n;
13 if ((ws = workQueues) != null && (n = ws.length) > 0) {
14 int s = indexSeed += SEED_INCREMENT; // 用于生成索引
15 int m = n - 1;
16 i = ((s << 1) | 1) & m; // 奇数
17 if (ws[i] != null) { // 碰撞了，选取别的槽位，找不到就扩容
18 int probes = 0; // 记录是否遍历一遍
19 int step = (n <= 4) ? 2 : ((n >>> 1) & EVENMASK) + 2; // 步长约长度的一半
20 while (ws[i = (i + step) & m] != null) { // 一直寻找，每次增加步长
21 if (++probes >= n) { // 如果遍历一遍，就扩容
22 workQueues = ws = Arrays.copyOf(ws, n <<= 1); // 扩容，每次扩大一倍长度
23 m = n - 1;
24 probes = 0;
25 }
26 }
27 }
28 w.hint = s; // 初始时为随机数
29 w.config = i | mode;
30 w.scanState = i; // 等于索引值
31 ws[i] = w; // 注册
32 }
33 } finally {
34 unlockRunState(rs, rs & ~RSLOCK); // 解锁
35 }
36 wt.setName(workerNamePrefix.concat(Integer.toString(i >>> 1))); // 设置名字
37 return w;
38 }
注册线程，为该线程创建一个工作队列，并注册到线程池中的奇数索引上，如果找了一圈没找到，则扩容。
deregisterWorker(ForkJoinWorkerThread wt, Throwable ex)
1 final void deregisterWorker(ForkJoinWorkerThread wt, Throwable ex) {
2 WorkQueue w = null;
3 if (wt != null && (w = wt.workQueue) != null) {
4 WorkQueue[] ws; // 从WorkQueue[]中起初WorkQueue(wt对应的)
5 int idx = w.config & SMASK; // 取得索引
6 int rs = lockRunState(); // 加锁
7 if ((ws = workQueues) != null && ws.length > idx && ws[idx] == w)
8 ws[idx] = null; // 注销
9 unlockRunState(rs, rs & ~RSLOCK); // 解锁
10 }
11 long c;
12 do {
13 } while (!U.compareAndSwapLong(this, CTL, c = ctl,
14 ((AC_MASK & (c - AC_UNIT)) | (TC_MASK & (c - TC_UNIT)) | (SP_MASK & c)))); // AC和TC都减1
15 if (w != null) {
16 w.qlock = -1; // 标记终止
17 w.transferStealCount(this);
18 w.cancelAll(); // 取消剩下的任务
19 }
20 for (;;) { // 可能的替换操作
21 WorkQueue[] ws;
22 int m, sp;
23 if (tryTerminate(false, false) || w == null || w.array == null || (runState & STOP) != 0
24 || (ws = workQueues) == null || (m = ws.length - 1) < 0) // 如果线程池已经终止，跳出循环
25 break;
26 if ((sp = (int) (c = ctl)) != 0) { // 如果有空闲线程，则唤醒一个线程替代已经注销的线程
27 if (tryRelease(c, ws[sp & m], AC_UNIT)) // 唤醒线程
28 break;
29 } else if (ex != null && (c & ADD_WORKER) != 0L) { // 如果没有空闲线程，并且没有达到并行度，创建一个
30 tryAddWorker(c);
31 break;
32 } else
33 break;
34 }
35 if (ex == null) // 异常处理
36 ForkJoinTask.helpExpungeStaleExceptions();
37 else
38 ForkJoinTask.rethrow(ex);
39 }
从线程池里注销线程，ws[idx] = null; // 注销，更新CTL，根据线程池的状态决定是否找一个自己的替代者（如果有空闲线程，则唤醒一个，否则，创建一个新的工作线程）
runWorker(WorkQueue w)
1 final void runWorker(WorkQueue w) {
2 w.growArray();
3 int seed = w.hint;
4 int r = (seed == 0) ? 1 : seed;
5 for (ForkJoinTask<?> t;;) {
6 if ((t = scan(w, r)) != null) // 扫描任务
7 w.runTask(t); // 执行任务
8 else if (!awaitWork(w, r)) // 没有任务执行，等待
9 break;
10 r ^= r << 13;
11 r ^= r >>> 17;
12 r ^= r << 5; // 更新随机值
13 }
14 }
- 扫描任务，扫描到一个任务，则执行此任务
- 如果没有扫描到任务，则调用awaitWork方法，返回true则继续参与扫描工作，否则任由其停止
scan(WorkQueue w, int r)
1 private ForkJoinTask<?> scan(WorkQueue w, int r) {
2 WorkQueue[] ws;
3 int m;
4 if ((ws = workQueues) != null && (m = ws.length - 1) > 0 && w != null) {
5 int ss = w.scanState;
6 for (int origin = r & m, k = origin, oldSum = 0, checkSum = 0;;) { // 初始起点为r，随机数
7 WorkQueue q;
8 ForkJoinTask<?>[] a;
9 ForkJoinTask<?> t;
10 int b, n;
11 long c;
12 if ((q = ws[k]) != null) { // 如果k槽位不为空，尝试从该任务队列里取任务
13 if ((n = (b = q.base) - q.top) < 0 && (a = q.array) != null) { // 有任务
14 long i = (((a.length - 1) & b) << ASHIFT) + ABASE; // 内存地址
15 if ((t = ((ForkJoinTask<?>) U.getObjectVolatile(a, i))) != null && q.base == b) { // 获取i地址的内容（任务）
16 if (ss >= 0) { // 如果active，更新array数组i索引处为空，表示任务已经取走，并更新base的值
17 if (U.compareAndSwapObject(a, i, t, null)) {
18 q.base = b + 1;
19 if (n < -1) // 通知其他线程
20 signalWork(ws, q);
21 return t;
22 }
23 } else if (oldSum == 0 && // 如果inactive，尝试active
24 w.scanState < 0)
25 tryRelease(c = ctl, ws[m & (int) c], AC_UNIT); // 激活栈顶工作线程对应的工作队列（任务队列，inactive -> active）
26 }
27 if (ss < 0) // 获取任务失败，重来，更新ss为最新的scanState
28 ss = w.scanState;
29 r ^= r << 1; // 更新随机值
30 r ^= r >>> 3;
31 r ^= r << 10;
32 origin = k = r & m; // 重新扫描
33 oldSum = checkSum = 0;
34 continue;
35 }
36 checkSum += b;
37 }
38 if ((k = (k + 1) & m) == origin) { // 最后没有扫描到任务，准备inactive此工作队列
39 if ((ss >= 0 || (ss == (ss = w.scanState))) && oldSum == (oldSum = checkSum)) {
40 if (ss < 0 || w.qlock < 0) // 已经inactive，跳出
41 break;
42 int ns = ss | INACTIVE; // 尝试inactive
43 long nc = ((SP_MASK & ns) | (UC_MASK & ((c = ctl) - AC_UNIT))); // AC减1，更新ctl
44 w.stackPred = (int) c; // 保存原栈顶工作队列索引
45 U.putInt(w, QSCANSTATE, ns); // 设置scanState
46 if (U.compareAndSwapLong(this, CTL, c, nc)) // CAS ctl
47 ss = ns; // ss取最新的scanState
48 else
49 w.scanState = ss; // CAS ctl失败，设置回scanState
50 }
51 checkSum = 0;
52 }
53 }
54 }
55 return null;
56 }
从随机的索引开始扫描任务，如果拿到任务，唤醒其他线程；如果没有拿到，并且已经扫描一圈了，尝试inactive自己所在的工作队列。
awaitWork(WorkQueue w, int r)
1 private boolean awaitWork(WorkQueue w, int r) {
2 if (w == null || w.qlock < 0) // w已经终止，返回false，不再扫描任务
3 return false;
4 for (int pred = w.stackPred, spins = SPINS, ss;;) {
5 if ((ss = w.scanState) >= 0) // 如果已经active，跳出，返回true，继续扫描任务
6 break;
7 else if (spins > 0) { // 如果spins > 0，自旋等待
8 r ^= r << 6;
9 r ^= r >>> 21;
10 r ^= r << 7;
11 if (r >= 0 && --spins == 0) { // 随机消耗自旋次数
12 WorkQueue v;
13 WorkQueue[] ws;
14 int s, j;
15 AtomicLong sc;
16 if (pred != 0 // 除了自己，还有等待的线程-工作队列
17 && (ws = workQueues) != null // 线程池还在
18 && (j = pred & SMASK) < ws.length // 前任索引还在池范围内
19 && (v = ws[j]) != null // 前任任务队列还在
20 && (v.parker == null || v.scanState >= 0)) // 前任线程已经唤醒，且工作队列已经激活
21 spins = SPINS; // 上面的一系列判断表明，很快就有任务了，先不park，继续自旋
22 }
23 } else if (w.qlock < 0) // 自旋之后，再次检查工作队列是否终止，若是，退出扫描
24 return false;
25 else if (!Thread.interrupted()) { // 如果线程中断了，清除中断标记，不考虑park，否则进入该分支
26 long c, prevctl, parkTime, deadline;
27 int ac = (int) ((c = ctl) >> AC_SHIFT) + (config & SMASK); // 计算活跃线程的个数
28 if ((ac <= 0 && tryTerminate(false, false)) || (runState & STOP) != 0) // 线程池正在终止，退出扫描
29 return false;
30 if (ac <= 0 && ss == (int) c) { // 自己是栈顶等待者
31 prevctl = (UC_MASK & (c + AC_UNIT)) | (SP_MASK & pred); // 设置为前一次的ctl
32 int t = (short) (c >>> TC_SHIFT); // 总的线程数
33 if (t > 2 && U.compareAndSwapLong(this, CTL, c, prevctl)) // 总线程数过多，直接退出扫描
34 return false;
35 parkTime = IDLE_TIMEOUT * ((t >= 0) ? 1 : 1 - t); // 计算等待时间
36 deadline = System.nanoTime() + parkTime - TIMEOUT_SLOP;
37 } else
38 prevctl = parkTime = deadline = 0L;
39 Thread wt = Thread.currentThread();
40 U.putObject(wt, PARKBLOCKER, this); // 加锁
41 w.parker = wt; // 设置parker，准备阻塞
42 if (w.scanState < 0 && ctl == c) // 阻塞前再次检查状态
43 U.park(false, parkTime);
44 U.putOrderedObject(w, QPARKER, null); // 唤醒后，置空parker
45 U.putObject(wt, PARKBLOCKER, null); // 解锁
46 if (w.scanState >= 0) // 已激活，跳出继续扫描
47 break;
48 if (parkTime != 0L && ctl == c && deadline - System.nanoTime() <= 0L
49 && U.compareAndSwapLong(this, CTL, c, prevctl)) // 超时，未等到任务，跳出，不再执行扫描任务，削减工作线程
50 return false; // shrink pool
51 }
52 }
53 return true;
54 }
若为扫描到任务，则会执行此方法。
- 首先会自旋等待，自旋过程中如果发现前任线程已经唤醒，且工作队列已经激活，说明已经有任务了，接着自旋等待
- 若发现工作队列已经终止，则返回false，表示自己退出扫描工作
- 如果线程中断了，清除中断标记，不考虑park，否则，进行下面一系列操作
- 如果发现当前线程数量过多，则直接返回false，自己不再参与扫描工作
- 计算阻塞时间，准备阻塞自己
- 阻塞前或唤醒后，都会判断线程池的状态，工作队列的状态，以判断自己是否继续参与扫描工作
fork()
1 public final ForkJoinTask<V> fork() { // 从top端压入任务
2 Thread t;
3 if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
4 ((ForkJoinWorkerThread)t).workQueue.push(this); // 当前工作线程所在的工作队列
5 else
6 ForkJoinPool.common.externalPush(this); // 外部提交任务
7 return this;
8 }
join()
1 public final V join() { // 调用doJoin()
2 int s;
3 if ((s = doJoin() & DONE_MASK) != NORMAL)
4 reportException(s);
5 return getRawResult();
6 }
doJoin()
1 private int doJoin() {
2 int s;
3 Thread t;
4 ForkJoinWorkerThread wt;
5 ForkJoinPool.WorkQueue w;
6 return (s = status) < 0 ? s
7 : ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
8 ? (w = (wt = (ForkJoinWorkerThread) t).workQueue).tryUnpush(this) && (s = doExec()) < 0 ? s
9 : wt.pool.awaitJoin(w, this, 0L)
10 : externalAwaitDone();
11 }
转换成下面的形式更好看点
1 private int doJoin() {
2 int s;
3 Thread t;
4 ForkJoinWorkerThread wt;
5 ForkJoinPool.WorkQueue w;
6
7 if((s = status) < 0) { // 已经有结果，直接返回
8 return s;
9 }else {
10 if((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) { // 如果是工作线程
11 if((w = (wt = (ForkJoinWorkerThread) t).workQueue).tryUnpush(this) // 尝试从本工作队列里取出等待的任务
12 && (s = doExec()) < 0) { // 如果取出了任务，则去执行它，并返回结果
13 return s;
14 }else {
15 return wt.pool.awaitJoin(w, this, 0L); // 否则，可能有别的线程把这个任务偷走了，执行内部等待方法
16 }
17 }else { // 如果是外部线程，执行外部等待方法
18 return externalAwaitDone();
19 }
20 }
21
22 }
externalAwaitDone()
1 private int externalAwaitDone() {
2 int s = ((this instanceof CountedCompleter) ? // 如果是CountedCompleter类型的任务，执行externalHelpComplete方法
3 ForkJoinPool.common.externalHelpComplete((CountedCompleter<?>) this, 0)
4 : ForkJoinPool.common.tryExternalUnpush(this) ? doExec() : 0); // 否则，执行tryExternalUnpush方法，成功则执行任务，否则，返回0
5 if (s >= 0 && (s = status) >= 0) { // 如果任务没有结束，则等待
6 boolean interrupted = false;
7 do {
8 if (U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) { // 将status设置为SIGNAL，等着被notify
9 synchronized (this) {
10 if (status >= 0) { // 任务未结束
11 try {
12 wait(0L); // 等待
13 } catch (InterruptedException ie) {
14 interrupted = true; // 记录中断标记
15 }
16 } else
17 notifyAll(); // 任务已经结束，通知等待的线程
18 }
19 }
20 } while ((s = status) >= 0); // 任务未结束，就一直等待
21 if (interrupted)
22 Thread.currentThread().interrupt(); // 补上中断
23 }
24 return s;
25 }
tryExternalUnpush(ForkJoinTask<?> task)
1 final boolean tryExternalUnpush(ForkJoinTask<?> task) {
2 WorkQueue[] ws;
3 WorkQueue w;
4 ForkJoinTask<?>[] a;
5 int m, s;
6 int r = ThreadLocalRandom.getProbe();
7 if ((ws = workQueues) != null && (m = ws.length - 1) >= 0 && (w = ws[m & r & SQMASK]) != null
8 && (a = w.array) != null && (s = w.top) != w.base) {
9 long j = (((a.length - 1) & (s - 1)) << ASHIFT) + ABASE;
10 if (U.compareAndSwapInt(w, QLOCK, 0, 1)) {
11 if (w.top == s && w.array == a && U.getObject(a, j) == task
12 && U.compareAndSwapObject(a, j, task, null)) { // 如果task在任务队列的top位置，则返回true; 否则，返回false
13 U.putOrderedInt(w, QTOP, s - 1);
14 U.putOrderedInt(w, QLOCK, 0);
15 return true;
16 }
17 U.compareAndSwapInt(w, QLOCK, 1, 0);
18 }
19 }
20 return false;
21 }
tryUnpush(ForkJoinTask<?> t)
1 final boolean tryUnpush(ForkJoinTask<?> t) { // 任务t在array的top位时，返回true; 否则，返回false
2 ForkJoinTask<?>[] a;
3 int s;
4 if ((a = array) != null && (s = top) != base
5 && U.compareAndSwapObject(a, (((a.length - 1) & --s) << ASHIFT) + ABASE, t, null)) {
6 U.putOrderedInt(this, QTOP, s);
7 return true;
8 }
9 return false;
10 }
doExec()
1 final int doExec() {
2 int s;
3 boolean completed;
4 if ((s = status) >= 0) {
5 try {
6 completed = exec(); // 执行具体的任务
7 } catch (Throwable rex) {
8 return setExceptionalCompletion(rex);
9 }
10 if (completed)
11 s = setCompletion(NORMAL);
12 }
13 return s;
14 }
awaitJoin(WorkQueue w, ForkJoinTask<?> task, long deadline)
1 final int awaitJoin(WorkQueue w, ForkJoinTask<?> task, long deadline) {
2 int s = 0;
3 if (task != null && w != null) {
4 ForkJoinTask<?> prevJoin = w.currentJoin; // 记录上一个join的任务
5 U.putOrderedObject(w, QCURRENTJOIN, task); // 设置task为当前join的任务
6 CountedCompleter<?> cc = (task instanceof CountedCompleter) ? (CountedCompleter<?>) task : null;
7 for (;;) {
8 if ((s = task.status) < 0) // 任务已经结束，跳出循环
9 break;
10 if (cc != null)
11 helpComplete(w, cc, 0); // CountedCompleter类型的任务调用helpComplete()方法
12 else if (w.base == w.top || w.tryRemoveAndExec(task)) // 任务队列为空或执行失败（任务被别的线程偷走了），帮助偷取者执行该任务
13 helpStealer(w, task);
14 if ((s = task.status) < 0) // 任务已经结束，跳出循环
15 break;
16 long ms, ns;
17 if (deadline == 0L) // 任务等待时间
18 ms = 0L;
19 else if ((ns = deadline - System.nanoTime()) <= 0L) // 超时退出
20 break;
21 else if ((ms = TimeUnit.NANOSECONDS.toMillis(ns)) <= 0L)
22 ms = 1L;
23 if (tryCompensate(w)) { // 尝试补偿策略（找一个替代者执行任务，自己在这儿等）
24 task.internalWait(ms); // 补偿成功，等待指定时间
25 U.getAndAddLong(this, CTL, AC_UNIT); // 活跃线程加1
26 }
27 }
28 U.putOrderedObject(w, QCURRENTJOIN, prevJoin); // 设置回前一个join的任务
29 }
30 return s;
31 }
tryRemoveAndExec(ForkJoinTask<?> task)
1 final boolean tryRemoveAndExec(ForkJoinTask<?> task) { // 该方法返回true, 代表可以去偷取任务执行了；否则，继续等待
2 ForkJoinTask<?>[] a;
3 int m, s, b, n;
4 if ((a = array) != null && (m = a.length - 1) >= 0 && task != null) {
5 while ((n = (s = top) - (b = base)) > 0) { // 从top开始，遍历任务队列，查找是否存在给定task
6 for (ForkJoinTask<?> t;;) {
7 long j = ((--s & m) << ASHIFT) + ABASE; // 计算任务内存地址，s递减
8 if ((t = (ForkJoinTask<?>) U.getObject(a, j)) == null) // 如果任务为空，
9 return s + 1 == top; // 如果top位为空，说明任务队列已经空了，返回true
10 else if (t == task) { // 找到给定任务task
11 boolean removed = false;
12 if (s + 1 == top) { // 任务在top位置，直接弹出pop
13 if (U.compareAndSwapObject(a, j, task, null)) {
14 U.putOrderedInt(this, QTOP, s);
15 removed = true;
16 }
17 } else if (base == b) // 如果不是在top，使用EmptyTask填补此位置
18 removed = U.compareAndSwapObject(a, j, task, new EmptyTask());
19 if (removed)
20 task.doExec(); // 执行任务
21 break; // 跳出，继续检查task.status，判断任务是否结束
22 } else if (t.status < 0 && s + 1 == top) { // 任务结束（取消），且目前检查的是top
23 if (U.compareAndSwapObject(a, j, t, null)) // 检查task是否在top位，如果是并置空top位，更新top为s(top - 1)
24 U.putOrderedInt(this, QTOP, s);
25 break; // 任务取消了
26 }
27 if (--n == 0) // 遍历结束
28 return false;
29 }
30 if (task.status < 0) // 任务结束
31 return false;
32 }
33 }
34 return true;
35 }
从top位置开始向下遍历任务，如果找到给定任务，把它从当前Worker的任务队列中移除并执行，移除的位置使用EmptyTask代替。如果任务队列为空或者任务未执行完毕返回true；任务执行完毕返回false.
helpStealer(WorkQueue w, ForkJoinTask<?> task)
1 private void helpStealer(WorkQueue w, ForkJoinTask<?> task) { // 帮助偷取者（偷取自己任务的线程）执行任务
2 WorkQueue[] ws = workQueues;
3 int oldSum = 0, checkSum, m;
4 if (ws != null && (m = ws.length - 1) >= 0 && w != null && task != null) {
5 do { // restart point
6 checkSum = 0; // for stability check
7 ForkJoinTask<?> subtask;
8 WorkQueue j = w, v; // v是子任务的偷取者
9 descent: for (subtask = task; subtask.status >= 0;) { // 从目标任务开始，记录当前Join的任务，也包括偷取者当前Join的任务，递归帮助
10 for (int h = j.hint | 1, k = 0, i;; k += 2) { // 每次跳2个，遍历奇数位索引
11 if (k > m) // 如果遍历一遍没有找到偷取者，跳出循环
12 break descent;
13 if ((v = ws[i = (h + k) & m]) != null) {
14 if (v.currentSteal == subtask) { // 定位到偷取者，更新hint为偷取者索引，方便下次定位
15 j.hint = i;
16 break;
17 }
18 checkSum += v.base; // 若没有定位到，则累加工作队列的base值，继续遍历
19 }
20 }
21 for (;;) { // 帮助偷取者执行任务
22 ForkJoinTask<?>[] a; // 偷取者的任务数组
23 int b;
24 checkSum += (b = v.base); // 累加偷取者的base值
25 ForkJoinTask<?> next = v.currentJoin; // 记录偷取者Join的任务
26 if (subtask.status < 0 || j.currentJoin != subtask || v.currentSteal != subtask) // subtask结束，或者数据不一致了(j.currentJoin != subtask || v.currentSteal != subtask)
27 break descent; // 跳出外层循环重来
28 if (b - v.top >= 0 || (a = v.array) == null) { // 偷取者的任务列表为空
29 if ((subtask = next) == null) // 偷取者的Join任务为空，跳出外层循环
30 break descent;
31 j = v; // 否则，j取v的值（j指向被偷者，v指向偷取者），且subtask指向next Join任务
32 break; // 继续遍历，寻找偷取者的偷取者（递归）
33 }
34 int i = (((a.length - 1) & b) << ASHIFT) + ABASE; // 偷取者的base内存地址
35 ForkJoinTask<?> t = ((ForkJoinTask<?>) U.getObjectVolatile(a, i)); // 获取base位置任务
36 if (v.base == b) {
37 if (t == null) // 任务为空，跳出外层循环（可能被别的线程拿走了）
38 break descent;
39 if (U.compareAndSwapObject(a, i, t, null)) { // poll（从base位置取出任务）
40 v.base = b + 1; // 更新base的值
41 ForkJoinTask<?> ps = w.currentSteal; // 记录调用者之前偷取的任务
42 int top = w.top; // 记录调用者的top值
43 do {
44 U.putOrderedObject(w, QCURRENTSTEAL, t); // 更新currentSteal为刚刚偷取到的任务
45 t.doExec(); // 指向任务
46 } while (task.status >= 0 && w.top != top && (t = w.pop()) != null); // 如果任务未结束，且自己任务队列不为空，优先处理自己队列里的任务
47 U.putOrderedObject(w, QCURRENTSTEAL, ps); // 把之前偷取的任务设置回currentSteal
48 if (w.base != w.top) // 自己队列来新任务了，直接返回
49 return;
50 }
51 }
52 }
53 }
54 } while (task.status >= 0 && oldSum != (oldSum = checkSum)); // Join的任务未结束，且任务在流动中，继续帮助执行
55 }
56 }
- 每次跳2个槽位，遍历奇数位索引，直到定位到偷取者，并记录偷取者的索引（hint = i），方便下次定位。
- 获取偷取者的任务列表，帮助其执行任务，如果执行过程中发现自己任务列表里有任务，则依次弹出执行。
- 如果偷取者任务队列为空，则帮助其执行Join任务，寻找偷取者的偷取者，如此往复，加快任务执行。
- 如果最后发现自己任务队列不为空（base != top)，则退出帮助。
- 最后判断任务task是否结束，如果未结束，且工作队列base和在变动中，说明偷取任务一直在进行，则重复以上操作，加快任务执行。
tryCompensate(WorkQueue w)
1 private boolean tryCompensate(WorkQueue w) { // 找一个替代者执行任务，自己等待任务结束
2 boolean canBlock;
3 WorkQueue[] ws;
4 long c;
5 int m, pc, sp;
6 if (w == null || w.qlock < 0 // 调用者正在终止
7 || (ws = workQueues) == null || (m = ws.length - 1) <= 0 // 线程池结束
8 || (pc = config & SMASK) == 0) // 并行度为0（不可用）
9 canBlock = false; // 不可阻塞
10 else if ((sp = (int) (c = ctl)) != 0) // 如果有空闲线程，释放空闲线程
11 canBlock = tryRelease(c, ws[sp & m], 0L);
12 else { // 没有空闲线程，尝试创建一个
13 int ac = (int) (c >> AC_SHIFT) + pc; // 活跃线程数
14 int tc = (short) (c >> TC_SHIFT) + pc; // 总的线程数
15 int nbusy = 0; // 验证饱和度（Running线程数是否等于总的线程数）
16 for (int i = 0; i <= m; ++i) {
17 WorkQueue v;
18 if ((v = ws[((i << 1) | 1) & m]) != null) { // 遍历两遍奇数索引槽位
19 if ((v.scanState & SCANNING) != 0)
20 break;
21 ++nbusy;
22 }
23 }
24 if (nbusy != (tc << 1) || ctl != c) // 遍历两遍奇数索引槽位，tc需要乘以2
25 canBlock = false; // 并不是所有的线程都在干活，或者数据（ctl）失效，不要阻塞
26 else if (tc >= pc && ac > 1 && w.isEmpty()) { // 总线程数大于并行度 && 活动线程数大于1 && 调用者任务队列为空
27 long nc = ((AC_MASK & (c - AC_UNIT)) | (~AC_MASK & c)); // AC - 1
28 canBlock = U.compareAndSwapLong(this, CTL, c, nc);
29 } else if (tc >= MAX_CAP || (this == common && tc >= pc + commonMaxSpares)) // TC达到最大容量
30 throw new RejectedExecutionException("Thread limit exceeded replacing blocked worker");
31 else {
32 boolean add = false;
33 int rs;
34 long nc = ((AC_MASK & c) | (TC_MASK & (c + TC_UNIT))); // 总的线程数加1，活跃线程数不变（补偿）
35 if (((rs = lockRunState()) & STOP) == 0)
36 add = U.compareAndSwapLong(this, CTL, c, nc);
37 unlockRunState(rs, rs & ~RSLOCK);
38 canBlock = add && createWorker(); // 创建工作线程
39 }
40 }
41 return canBlock;
42 }
- 调用者队列不为空，并且有空闲工作线程，唤醒空闲线程（tryRelease）
- 线程池未停止，活跃线程数不足，新建一个工作线程（createWorker）
- 工作队列正在停止或线程池停止，总线程数大于并行度 && 活动线程数大于1 && 调用者任务队列为空，不需要补偿
awaitQuiescence(long timeout, TimeUnit unit)
1 public boolean awaitQuiescence(long timeout, TimeUnit unit) { // 等待所有的任务执行结束
2 long nanos = unit.toNanos(timeout);
3 ForkJoinWorkerThread wt;
4 Thread thread = Thread.currentThread();
5 if ((thread instanceof ForkJoinWorkerThread) && (wt = (ForkJoinWorkerThread) thread).pool == this) {
6 helpQuiescePool(wt.workQueue); // 如果是工作线程，帮助执行任务，使其尽快结束
7 return true;
8 }
9 long startTime = System.nanoTime();
10 WorkQueue[] ws;
11 int r = 0, m;
12 boolean found = true;
13 while (!isQuiescent() && (ws = workQueues) != null && (m = ws.length - 1) >= 0) { // 任务未执行结束
14 if (!found) { // 未找到任务
15 if ((System.nanoTime() - startTime) > nanos)
16 return false; // 超时返回
17 Thread.yield(); // 让出CPU时间片，让其他线程快点干活
18 }
19 found = false;
20 for (int j = (m + 1) << 2; j >= 0; --j) { // j初始值是4 * ws.length, 然后递减，这是要遍历4次的节奏
21 ForkJoinTask<?> t;
22 WorkQueue q;
23 int b, k;
24 if ((k = r++ & m) <= m && k >= 0 && (q = ws[k]) != null && (b = q.base) - q.top < 0) {
25 found = true;
26 if ((t = q.pollAt(b)) != null) // 从base位置取出任务并执行
27 t.doExec();
28 break;
29 }
30 }
31 }
32 return true;
33 }
helpQuiescePool(WorkQueue w)
1 final void helpQuiescePool(WorkQueue w) {
2 ForkJoinTask<?> ps = w.currentSteal; // 保存当前偷取的任务
3 for (boolean active = true;;) {
4 long c;
5 WorkQueue q;
6 ForkJoinTask<?> t;
7 int b;
8 w.execLocalTasks(); // 首先执行自己队列里的任务
9 if ((q = findNonEmptyStealQueue()) != null) { // 如果查找到非空WorkQueue
10 if (!active) { // 当前是inactive
11 active = true; // 重新设置为active
12 U.getAndAddLong(this, CTL, AC_UNIT); // AC + 1
13 }
14 if ((b = q.base) - q.top < 0 && (t = q.pollAt(b)) != null) { // 任务不为空，从base位置取任务
15 U.putOrderedObject(w, QCURRENTSTEAL, t); // 记录t为当前偷取的任务
16 t.doExec(); // 开始干活
17 if (++w.nsteals < 0) // 增加计数
18 w.transferStealCount(this); // 将自己的计数添加到线程池的总计数上面去
19 }
20 } else if (active) { // 是active，但是没找到任务
21 long nc = (AC_MASK & ((c = ctl) - AC_UNIT)) | (~AC_MASK & c); // AC - 1
22 if ((int) (nc >> AC_SHIFT) + (config & SMASK) <= 0)
23 break; // AC为0，退出
24 if (U.compareAndSwapLong(this, CTL, c, nc)) // CAS ctl的值
25 active = false; // inactive
26 } else if ((int) ((c = ctl) >> AC_SHIFT) + (config & SMASK) <= 0 // inactive, AC == 0
27 && U.compareAndSwapLong(this, CTL, c, c + AC_UNIT)) // AC + 1, 保证AC至少为1
28 break;
29 }
30 U.putOrderedObject(w, QCURRENTSTEAL, ps); // 设置回偷取的任务
31 }
awaitTermination(long timeout, TimeUnit unit)
1 public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
2 if (Thread.interrupted())
3 throw new InterruptedException();
4 if (this == common) {
5 awaitQuiescence(timeout, unit);
6 return false;
7 }
8 long nanos = unit.toNanos(timeout);
9 if (isTerminated())
10 return true;
11 if (nanos <= 0L)
12 return false;
13 long deadline = System.nanoTime() + nanos;
14 synchronized (this) {
15 for (;;) { // 等待线程池终止
16 if (isTerminated())
17 return true;
18 if (nanos <= 0L)
19 return false;
20 long millis = TimeUnit.NANOSECONDS.toMillis(nanos);
21 wait(millis > 0L ? millis : 1L);
22 nanos = deadline - System.nanoTime();
23 }
24 }
25 }
tryTerminate(boolean now, boolean enable)
1 private boolean tryTerminate(boolean now, boolean enable) {
2 int rs;
3 if (this == common) // 公共线程池，不能shutdown
4 return false;
5 if ((rs = runState) >= 0) {
6 if (!enable)
7 return false;
8 rs = lockRunState(); // 进入SHUTDOWN阶段
9 unlockRunState(rs, (rs & ~RSLOCK) | SHUTDOWN);
10 }
11
12 if ((rs & STOP) == 0) { // 准备进入STOP阶段
13 if (!now) { // 必要的检查
14 for (long oldSum = 0L;;) {
15 WorkQueue[] ws;
16 WorkQueue w;
17 int m, b;
18 long c;
19 long checkSum = ctl;
20 if ((int) (checkSum >> AC_SHIFT) + (config & SMASK) > 0)
21 return false; // 如果有活动的工作线程，还不能停止
22 if ((ws = workQueues) == null || (m = ws.length - 1) <= 0)
23 break;
24 for (int i = 0; i <= m; ++i) {
25 if ((w = ws[i]) != null) {
26 if ((b = w.base) != w.top || w.scanState >= 0 || w.currentSteal != null) {
27 tryRelease(c = ctl, ws[m & (int) c], AC_UNIT);
28 return false; // 有任务在执行，还不能停止
29 }
30 checkSum += b; // 累加base值
31 if ((i & 1) == 0)
32 w.qlock = -1; // 偶数索引工作队列，qlock = -1, 拦截从外部提交的任务
33 }
34 }
35 if (oldSum == (oldSum = checkSum)) // 稳定了，退出
36 break;
37 }
38 }
39 if ((runState & STOP) == 0) { // 如果now等于true，立刻进入STOP结点
40 rs = lockRunState();
41 unlockRunState(rs, (rs & ~RSLOCK) | STOP);
42 }
43 }
44
45 int pass = 0;
46 for (long oldSum = 0L;;) {
47 WorkQueue[] ws;
48 WorkQueue w;
49 ForkJoinWorkerThread wt;
50 int m;
51 long checkSum = ctl;
52 if ((short) (checkSum >>> TC_SHIFT) + (config & SMASK) <= 0 || (ws = workQueues) == null
53 || (m = ws.length - 1) <= 0) { // 可以终止了
54 if ((runState & TERMINATED) == 0) {
55 rs = lockRunState();
56 unlockRunState(rs, (rs & ~RSLOCK) | TERMINATED); // 进入TERMINATED阶段
57 synchronized (this) {
58 notifyAll(); // 唤醒所有线程
59 }
60 }
61 break; // 跳出
62 }
63 for (int i = 0; i <= m; ++i) {
64 if ((w = ws[i]) != null) {
65 checkSum += w.base;
66 w.qlock = -1; // 设置不可用
67 if (pass > 0) {
68 w.cancelAll(); // 取消所有的任务
69 if (pass > 1 && (wt = w.owner) != null) {
70 if (!wt.isInterrupted()) {
71 try {
72 wt.interrupt(); // 中断线程
73 } catch (Throwable ignore) {
74 }
75 }
76 if (w.scanState < 0)
77 U.unpark(wt); // 唤醒线程
78 }
79 }
80 }
81 }
82 if (checkSum != oldSum) { // 不稳定，重来
83 oldSum = checkSum;
84 pass = 0;
85 } else if (pass > 3 && pass > m) // 退出
86 break;
87 else if (++pass > 1) { // 出队
88 long c;
89 int j = 0, sp;
90 while (j++ <= m && (sp = (int) (c = ctl)) != 0)
91 tryRelease(c, ws[sp & m], AC_UNIT);
92 }
93 }
94 return true;
95 }
SHUTDOWN(!common) -> STOP(无任务执行) -> TERMINATED(over)
fork-join
1.有一个大的任务Task(8), 最终被分解成8个小任务Task(1)
2.将Task(8)加入到任务队列里面(偶数索引，图中未显示)，线程A偷取到Task(8)，fork了2个Task(4)，push到任务队列里面
3.pop出Task(4), fork出2个Task(2)，push到任务队列里面
4. pop出Task(2), fork出2个Task(1), push到任务队列里面
5.pop出任务Task(1)，此刻已经达到最小粒度，开始执行该任务；与此同时，线程B从底部(base)位置steal走了Task(4)
6.线程B拿到Task(4)之后，fork出了2个Task(2)，push到任务队列里面
7.线程A执行完自己的任务后，由于Task(4).join()，索性定位到偷走自己任务的线程B所在的工作队列，帮助其执行任务，整体加快任务进度，帮助的方式也是steal
以上是最简单的一种fork.join方式。
行文至此结束。
尊重他人的劳动，转载请注明出处：http://www.cnblogs.com/aniao/p/aniao_fjp.html
来源：https://www.cnblogs.com/aniao/p/aniao_fjp.html