ForkJoin框架源码分析（详细）
ForkJoin简介及使用
ForkJoin框架是CompletableFuture和java8 stream使用到的框架。主要用于分片处理的场景。
可以通过自定义分片粒度来实现任务分解。并行处理数据。
CompletableFuture能够实现响应式编程。但未用到ForkJoin的分片。所以对于CompletableFuture来说，ForkJoin仅是一个公用的线程池而已
stream能让java处理数据更加优雅，并行流stream使用了ForkJoin的分片处理(参考java.util.stream.ForEachTask等类)
ForkJoin源码分析
从CompletableFuture的使用进入
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println("hello world");
return 0;
});
CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(() ->
System.out.println("hello world")
);
completableFuture1 = CompletableFuture.runAsync(() ->
System.out.println("hello world"), Executors.newSingleThreadExecutor());
completableFuture.get();
CompletableFuture提供了提交Runnable和Callable任务的接口。分别对应runAsync(Runnable r)和supplyAsync(Callable c)。runAsync(Runnable r)有一个重载方法runAsync(Runnable r, Executor e) 支持自定义线程池。如果调用runAsync(Runnable r)方法，则代表使用ForkJoinPool作为线程池。
ForkJoinPool源码剖析
public static CompletableFuture<Void> runAsync(Runnable runnable) {
return asyncRunStage(asyncPool, runnable);
}
asyncPool参数解析
// ForkJoinPool.parallelism默认为可用CPU的数量
// parallelism可以自行设置
private static final boolean useCommonPool =
(ForkJoinPool.getCommonPoolParallelism() > 1);
// 当parallelism并行度等于1(不并行处理)时使用ThreadPerTaskExecutor线程池
private static final Executor asyncPool = useCommonPool ?
ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
// ForkJoinPool每个任务可能有多个线程进行处理
// ThreadPerTaskExecutor每个任务创建一个线程来进行处理
static final class ThreadPerTaskExecutor implements Executor {
public void execute(Runnable r) { new Thread(r).start(); }
}
ForkJoinPool的类图
CompletableFuture#asyncRunStage方法内容
static CompletableFuture<Void> asyncRunStage(Executor e, Runnable f) {
if (f == null) throw new NullPointerException();
CompletableFuture<Void> d = new CompletableFuture<Void>();
// 这里调用的是ForkJoinPool#execute(Runnable task)方法
e.execute(new AsyncRun(d, f));
return d;
}
AsyncRun继承了ForkJoinTask类，实现了Runnable接口
static final class AsyncRun extends ForkJoinTask<Void>
implements Runnable, AsynchronousCompletionTask
ForkJoinPool#execute(Runnable task)方法
public void execute(Runnable task) {
if (task == null)
throw new NullPointerException();
ForkJoinTask<?> job;
if (task instanceof ForkJoinTask<?>) // avoid re-wrap
// 从CompletableFuture提交的任务会走到这
job = (ForkJoinTask<?>) task;
else
job = new ForkJoinTask.RunnableExecuteAction(task);
// 将任务放入工作队列
externalPush(job);
}
ForkJoinPool#externalPush(ForkJoinTask task)方法，将任务放入工作队列
final void externalPush(ForkJoinTask<?> task) {
WorkQueue[] ws; WorkQueue q; int m;
int r = ThreadLocalRandom.getProbe();
int rs = runState;
// 如果工作队列不为空(ws = workQueues) != null && (m = (ws.length - 1)) >= 0
// q = ws[m & r & SQMASK]，q为ws中随机的偶数索引。
// SQMASK为0x007e 126二进制位为11111110所以q的结果永远为偶数
// U.compareAndSwapInt(q, QLOCK, 0, 1)加锁，QLOCK为第q个WorkQueue对象的锁的引用
if ((ws = workQueues) != null && (m = (ws.length - 1)) >= 0 &&
(q = ws[m & r & SQMASK]) != null && r != 0 && rs > 0 &&
U.compareAndSwapInt(q, QLOCK, 0, 1)) {
ForkJoinTask<?>[] a; int am, n, s;
if ((a = q.array) != null &&
(am = a.length - 1) > (n = (s = q.top) - q.base)) {
int j = ((am & s) << ASHIFT) + ABASE;
// 把任务放入WorkQueue[q].array的队尾
U.putOrderedObject(a, j, task);
// 队列的top++；
U.putOrderedInt(q, QTOP, s + 1);
// 解锁
U.putIntVolatile(q, QLOCK, 0);
// 处于active的工作线程不够则新建work来
if (n <= 1)
signalWork(ws, q);
return;
}
// 解锁
U.compareAndSwapInt(q, QLOCK, 1, 0);
}
// 如果工作队列为空，或者加锁失败，则初始化工作队列后提交任务
externalSubmit(task);
}
private void externalSubmit(ForkJoinTask<?> task) {
int r; // initialize caller's probe
if ((r = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit();
r = ThreadLocalRandom.getProbe();
}
// 循环退出条件
// 抛出RejectedExecutionException异常(runState为关闭状态)
// 任务提交成功
for (;;) {
WorkQueue[] ws; WorkQueue q; int rs, m, k;
boolean move = false;
if ((rs = runState) < 0) {
tryTerminate(false, false); // help terminate
throw new RejectedExecutionException();
}
// 没初始化，就初始化WorkQueue
else if ((rs & STARTED) == 0 || // initialize
((ws = workQueues) == null || (m = ws.length - 1) < 0)) {
int ns = 0;
// 加锁，锁标志位低位置为1， rs |= 1;
rs = lockRunState();
try {
// 没初始化，则新建一个WorkQueue
if ((rs & STARTED) == 0) {
U.compareAndSwapObject(this, STEALCOUNTER, null,
new AtomicLong());
// 创建一个size为2的n次方的WorkQueue数组
int p = config & SMASK; // ensure at least 2 slots
int n = (p > 1) ? p - 1 : 1;
n |= n >>> 1; n |= n >>> 2; n |= n >>> 4;
n |= n >>> 8; n |= n >>> 16; n = (n + 1) << 1;
workQueues = new WorkQueue[n];
// 将置为已初始化状态
ns = STARTED;
}
} finally {
// 解锁并设置runState为已初始化状态
unlockRunState(rs, (rs & ~RSLOCK) | ns);
}
}
// 判断该任务所在WorkQueue是否为空
else if ((q = ws[k = r & m & SQMASK]) != null) {
if (q.qlock == 0 && U.compareAndSwapInt(q, QLOCK, 0, 1)) {
ForkJoinTask<?>[] a = q.array;
int s = q.top;
boolean submitted = false; // initial submission or resizing
try { // locked version of push
if ((a != null && a.length > s + 1 - q.base) ||
(a = q.growArray()) != null) {
int j = (((a.length - 1) & s) << ASHIFT) + ABASE;
U.putOrderedObject(a, j, task);
U.putOrderedInt(q, QTOP, s + 1);
submitted = true;
}
} finally {
U.compareAndSwapInt(q, QLOCK, 1, 0);
}
// 任务提交成功
if (submitted) {
// 如果worker太少，则创建worker，没有空闲的worker则啥也不干。
signalWork(ws, q);
return;
}
}
// 未提交成功则继续此循环
move = true; // move on failure
}
else if (((rs = runState) & RSLOCK) == 0) { // create new queue
q = new WorkQueue(this, null);
q.hint = r;
q.config = k | SHARED_QUEUE;
q.scanState = INACTIVE;
rs = lockRunState(); // publish index
if (rs > 0 && (ws = workQueues) != null &&
k < ws.length && ws[k] == null)
ws[k] = q; // else terminated
unlockRunState(rs, rs & ~RSLOCK);
}
else
move = true; // move if busy
if (move)
r = ThreadLocalRandom.advanceProbe(r);
}
}