《java.util.concurrent 包源码阅读》25 Fork/Join框架之Fork与Work-Stealing（重写23，24）

在写前面两篇文章23和24的时候自己有很多细节搞得不是很明白，这篇文章把Fork和Work-Stealing相关的源代码重新梳理一下。

首先来看一些线程池定义的成员变量：

关于scanGuard：

volatile int scanGuard;

private static final int SG_UNIT = 1 << 16;

private static final int  SMASK      = 0xffff;

scanGuard低位16位数值（0到15位）始终等于2的N次方减去1，代表的是大于Worker线程数的最小的2的N次方减去1。因此每次要取低16位数据时都要用到SMASK。

scanGuard的第16位是一个标志位，被当成是一个更新worker线程数组的锁使用。当该位的数据是1时，表示worker线程数组被锁住，其他线程无法更新worker线程。

要更新第16位的数值，就需要用到SG_UNIT。

再来说说与任务队列有关的三个变量：

// 存储任务的数组，长度是2的N次方
ForkJoinTask<?>[] queue;

// 最后一个元素数组下标+1
// 如果把数组看成是队列，那么该位置就是队列尾部（FIFO添加元素）
// 如果看成是栈，那么该位置就栈顶(LIFO拿走元素)
// 只能当前线程会使用这个数值，不存在多线程问题，因此不用volatile
int queueTop;

// 第一个元素的数组下标
// 也就是队列的头部的位置，从队列中拿走元素时，该数值加1
// 其他线程偷任务（FIFO方式）时会更新这个变量，因此需要volatile
volatile int queueBase;

任务队列的设计和Work-Stealing要求的一致（支持LIFO和FIFO）。

下面是scan方法源代码解析（补充了一些细节）：

    private boolean scan(ForkJoinWorkerThread w, int a) {
        int g = scanGuard;
        // parallelism表示并发数，一般等于CPU可以同时运行的线程数，
        // 默认值是Runtime类的availableProcessors方法返回值，表示
        // 处理器的数量，因此parallelism大于0。
        // a是活跃的Worker线程数，肯定大于等于0，因此
        // 条件parallelism == 1 - a满足意味着parallelism为1而a为0。
        // 也就是当前没有Worker线程在执行任务。blockedCount为0意味
        // 着没有线程因为join被阻塞。
        // 两个条件同时满足也就意味既没有任何线程在运行，那么也就
        // 意味着不可能有任务存放于worker线程，所以m=0，也就是没
        // 法偷任务。
        // g & SMASK返回的值scanGuard的0到15位的数值(一个2的N次方减去1的值)
        int m = (parallelism == 1 - a && blockedCount == 0) ? 0 : g & SMASK;
        ForkJoinWorkerThread[] ws = workers;
        if (ws == null || ws.length <= m)
            return false;

        // 偷任务
        for (int r = w.seed, k = r, j = -(m + m); j <= m + m; ++j) {
            ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
            // 从线程队列中随机获取一个worker线程
            ForkJoinWorkerThread v = ws[k & m];
            // v!=null表示随机索引的线程存在
            // queueBase不等于queueTop表示线程的任务队列不为空
            // v.queue不为null表示任务队列已经被初始化
            // (q.length - 1) 同样是2的N次方减一，和b相与得到一个
            // 在数组长度范围内的数组下标
            // 这一串判断是为了确认找到了一个有任务的线程来偷任务
            if (v != null && (b = v.queueBase) != v.queueTop &&
                (q = v.queue) != null && (i = (q.length - 1) & b) >= 0) {
                // u是计算Unsafe的索引，用以CAS操作
                long u = (i << ASHIFT) + ABASE;

                // (t = q[i]) != null用以判断数组该位置存有任务
                // v.queueBase == b为了确认没有线程拿走任务
                // CAS操作把该数组元素设为null表示拿走任务
                if ((t = q[i]) != null && v.queueBase == b &&
                    UNSAFE.compareAndSwapObject(q, u, t, null)) {
                    //v.queueBase = b + 1更新队列头部位置
                    int d = (v.queueBase = b + 1) - v.queueTop;
                    v.stealHint = w.poolIndex;
                    // d是偷走一个任务后任务队列的长度
                    if (d != 0)
                        signalWork();
                    w.execTask(t);
                }
                r ^= r << 13; r ^= r >>> 17; w.seed = r ^ (r << 5);
                // false表示扫描到了任务
                return false;
            }
            // j < 0时随机选取Worker线程
            else if (j < 0) {                     // 异或移位，更新k
                r ^= r << 13; r ^= r >>> 17; k = r ^= r << 5;
            }
            // j >= 0后按个尝试线程
            else
                ++k;
        }

        // 如果扫描不到任务，但是scanGuard被更新了，
        // 说明有新的Worker线程被添加进来
        if (scanGuard != g)
            return false;
        else {
            // 从线程池的任务队列中取出任务来执行
            // 逻辑和上面从其他线程的任务队列偷任务类似
            ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
            if ((b = queueBase) != queueTop &&
                (q = submissionQueue) != null &&
                (i = (q.length - 1) & b) >= 0) {
                long u = (i << ASHIFT) + ABASE;
                if ((t = q[i]) != null && queueBase == b &&
                    UNSAFE.compareAndSwapObject(q, u, t, null)) {
                    queueBase = b + 1;
                    w.execTask(t);
                }
                return false;
            }
            return true;
        }
    }

Worker线程一上来就直接偷其他线程的任务，自己的任务不管吗？来看execTask就知道了：

    final void execTask(ForkJoinTask<?> t) {
        currentSteal = t;
        for (;;) {
            // 首先执行偷来的任务
            if (t != null)
                t.doExec();
            // 先把自己的任务全部执行，再返回去偷别的线程去执行
            if (queueTop == queueBase)
                break;
            // locallyFifo一般来自线程池的设置
            // 为true使用FIFO的方式从队列中取任务执行
            // 为false使用LIFO的方式（栈的方式）取任务
            t = locallyFifo ? locallyDeqTask() : popTask();
        }
        // 更新偷任务的计数
        ++stealCount;
        currentSteal = null;
    }

在线程池的work方法（见第23篇）中还涉及到一个tryAwaitWork方法，以下是该方法的解析：

    private boolean tryAwaitWork(ForkJoinWorkerThread w, long c) {
        int v = w.eventCount;
        // ctl值的0-30位存储了等待线程的信息
        //（参考第23篇中work方法解析中关于ctl的解释）
        // 等待线程是按照栈的方式存储的，因此这里把原来排
        // 第一位的等待线程设为当前线程的下一个，当前线程
        // 变成排到第一位
        w.nextWait = (int)c;
        // 正在运行的线程数减少1，因此把48-63位的AC值减1
        long nc = (long)(v & E_MASK) | ((c - AC_UNIT) & (AC_MASK|TC_MASK));

        // 两个条件等同于ctl发生了变化
        if (ctl != c || !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
            long d = ctl;
            // 第一个条件表示第一个等待线程已经发生变化（ctl值的0-30位）
            // 第二个条件表示增加了正在运行的线程数变少
            // 两个条件都满足时返回true，强制再扫描一次
            return (int)d != (int)c && ((d - c) & AC_MASK) >= 0L;
        }

        //
        for (int sc = w.stealCount; sc != 0;) {   // accumulate stealCount
            long s = stealCount;
            // 把线程w的stealCount加到线程池的stealCount上，然后再设置w
            // 的stealCount为0
            if (UNSAFE.compareAndSwapLong(this, stealCountOffset, s, s + sc))
                sc = w.stealCount = 0;
            // 线程自己的eventCount发生变化，则下次再更新stealCount
            else if (w.eventCount != v)
                return true;
        }
        // shutdown或者tryTerminate不为false表示当前的线程没有处于正在关闭状态
        // (int)c != 0表示有线程在等待
        // parallelism + (int)(nc >> AC_SHIFT)表示活跃线程数为0
        // blockedCount == 0表示正在join等待的线程数为0
        // quiescerCount == 0表示Quiesce线程池中的线程数为0
        // 关于Quiesce线程池后面会做介绍
        if ((!shutdown || !tryTerminate(false)) &&
            (int)c != 0 && parallelism + (int)(nc >> AC_SHIFT) == 0 &&
            blockedCount == 0 && quiescerCount == 0)
            // 满足上述条件说明当前线程池没有任何线程在工作（包括运行
            // 任务和join等待），这种情况下，这个线程就会等待一段时间
            // 然后如果还是没有任何事件发生，就会把这个线程关闭。
            idleAwaitWork(w, nc, c, v);
        for (boolean rescanned = false;;) {
            if (w.eventCount != v)
                return true;

            // 尝试把当前线程从等待队列中移除，
            // 一旦移除，eventCount就会发生变化，然后返回
            if (!rescanned) {
                int g = scanGuard, m = g & SMASK;
                ForkJoinWorkerThread[] ws = workers;
                if (ws != null && m < ws.length) {
                    rescanned = true;
                    for (int i = 0; i <= m; ++i) {
                        ForkJoinWorkerThread u = ws[i];
                        if (u != null) {
                            if (u.queueBase != u.queueTop &&
                                !tryReleaseWaiter())
                                rescanned = false;
                            if (w.eventCount != v)
                                return true;
                        }
                    }
                }
                if (scanGuard != g ||
                    (queueBase != queueTop && !tryReleaseWaiter()))
                    rescanned = false;
                if (!rescanned)
                    // 让出控制权，减少冲突
                    Thread.yield();
                else
                    // 在Park之前清除中断状态
                    Thread.interrupted();
            }
            else {
                w.parked = true;
                if (w.eventCount != v) {
                    w.parked = false;
                    return true;
                }
                LockSupport.park(this);
                rescanned = w.parked = false;
            }
        }
    }

零零碎碎说了关于Fork的部分，后面会继续说关于Join的过程。