Fork-Join 原理深入分析（二）

本文是将 Fork-Join 复杂且较为庞大的框架分成5个小点来分析 Fork-Join 框架的实现原理，一个个点地理解透 Fork-Join 的核心原理。

1. Frok-Join 框架的核心类的结构分析

Fork-Join 框架有三个核心类：ForkJoinPool，ForkJoinWorkerThread，ForkJoinTask。下面将分析这三个类的数据结构，初步了解三个类的核心成员。

ForkJoinPool

//继承了 AbstractExecutorService 类

public class ForkJoinPool extends AbstractExecutorService{

    //任务队列数组，存储了所有任务队列，包括 内部队列 和 外部队列

    volatile WorkQueue[] workQueues;     // main registry

    //一个静态常量，ForkJoinPool 提供的内部公用的线程池

    static final ForkJoinPool common;

    //默认的线程工厂类

  public static final ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory;

}

ForkJoinWorkerThread

//继承了 Thread 类

public class ForkJoinWorkerThread extends Thread {

  //线程工作的线程池，即此线程所属的线程池

  final ForkJoinPool pool;

  // 线程的内部队列

  final ForkJoinPool.WorkQueue workQueue;

//.....

}

2. ForkJoinPool 中线程的创建

2.1 默认的线程工厂类

ForkJoinPool 中的线程是由默认的线程工厂类 defaultForkJoinWorkerThreadFactory 创建的

//默认的工厂类

  public static final ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory;

defaultForkJoinWorkerThreadFactory =

            new DefaultForkJoinWorkerThreadFactory();

defaultForkJoinWorkerThreadFactory 创建线程的方法 newThread()，其实就是传入当前的线程池，直接创建。

 /**

     * Default ForkJoinWorkerThreadFactory implementation; creates a

     * new ForkJoinWorkerThread.

     */

    static final class DefaultForkJoinWorkerThreadFactory

        implements ForkJoinWorkerThreadFactory {

        public final ForkJoinWorkerThread newThread(ForkJoinPool pool) {

            return new ForkJoinWorkerThread(pool);

        }

    }

2.2 ForkJoinWorkerThread 的构造方法

 protected ForkJoinWorkerThread(ForkJoinPool pool) {

        // Use a placeholder until a useful name can be set in registerWorker

        super("aForkJoinWorkerThread");

        //线程工作的线程池，即创建这个线程的线程池

        this.pool = pool;

        //注册线程到线程池中，并返回此线程的内部任务队列

        this.workQueue = pool.registerWorker(this);

    }

创建一个工作线程，最后一步还要注册到其所属的线程池中，看下面源码，注册的过程可以分为两步：

创建一个新的任务队列
为此任务队列分配一个线程池的索引，将任务队列存储在线程数组 workQueues 的此索引位置，并返回这个任务队列，作为线程的内部任务队列。线程注册成功。

  final WorkQueue registerWorker(ForkJoinWorkerThread wt) {

        UncaughtExceptionHandler handler;

        wt.setDaemon(true);               // configure thread

        if ((handler = ueh) != null)

            wt.setUncaughtExceptionHandler(handler);

        //创建一个任务队列

        WorkQueue w = new WorkQueue(this, wt);

        int i = 0;                             //分配一个线程池的索引

        int mode = config & MODE_MASK;

        int rs = lockRunState();

        try {

            WorkQueue[] ws; int n;                    // skip if no array

            if ((ws = workQueues) != null && (n = ws.length) > 0) {

                int s = indexSeed += SEED_INCREMENT; // unlikely to collide

                int m = n - 1;

                //计算 索引

                i = ((s << 1) | 1) & m;               // odd-numbered indices

               if (ws[i] != null) {                   //如果索引冲突

                    int probes = 0;                   // step by approx half n

                    int step = (n <= 4) ? 2 : ((n >>> 1) & EVENMASK) + 2;

                    while (ws[i = (i + step) & m] != null) {

                        if (++probes >= n) {

                            //扩容：以原来的数组的长度的两倍来创建一个新的数组，再复制旧数组的内衣

                            workQueues = ws = Arrays.copyOf(ws, n <<= 1);

                            m = n - 1;

                            probes = 0;

                        }

                    }

                }

                w.hint = s;                           // use as random seed

                w.config = i | mode;

                w.scanState = i;                      // publication fence

                //刚创建的任务队列加入到线程池的 任务队列数组中

                ws[i] = w;

            }

        } finally {

            unlockRunState(rs, rs & ~RSLOCK);

        }

        wt.setName(workerNamePrefix.concat(Integer.toString(i >>> 1)));

        return w;

    }

对应注册线程，ForkJoinPool 也提供了一个取消线程注册的方法 deregisterWorker()，在线程被销毁的时候调用，此处就不说了。

3. ForkJoinTask的fork()、join()方法

在上一篇文章中，我们在实现分治编程时，主要就是调用 ForkJoinTask 的 fork() 和 join() 方法。fork() 方法用于提交子任务，而 join() 方法则用于等待子任务的完成。而这个过程中，将涉及到 “工作窃取算法”。

3.1 fork( ) 方法提交任务

先来看一下 fork() 方法的源码

public final ForkJoinTask<V> fork() {

        Thread t;

        //判断是否是一个 工作线程

        if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)

            //加入到内部队列中

            ((ForkJoinWorkerThread)t).workQueue.push(this);

        else//由 common 线程池来执行任务

            ForkJoinPool.common.externalPush(this);

        return this;

    }

源码中，fork()方法先判断当前线程（调用fork()来提交任务的线程）是不是一个 ForkJoinWorkerThread 的工作线程，如果是，则将任务加入到内部队列中，否则，由 ForkJoinPool 提供的内部公用的线程池 common 线程池 来执行这个任务。

   //ForkJoinPool 提供的内部公用的线程池

    static final ForkJoinPool common;

顺便说一下，根据上面的说法，意味着我们可以在普通线程池中直接调用 fork() 方法来提交任务到一个默认提供的线程池中。这将非常方便。假如，你要在程序中处理大任务，需要分治编程，但你仅仅只处理一次，以后就不会用到，而且任务不算太大，不需要设置特定的参数，那么你肯定不想为此创建一个线程池，这时默认的提供的线程池将会很有用。

下面是我基于上一篇文章例子改造的，CountTask 类在我上一篇文章中找到

public class Test_34 {

	public static void main(String[] args) throws InterruptedException, ExecutionException {

		// 创建一个计算任务，计算 由1加到12

		CountTask countTask2 = new CountTask(1, 12);

        //直接在main线程中调用 fork 来提交任务,

		countTask2.fork();

        //没有创建线程池，使用commonPool线程池

		System.out.println(countTask2.get());

	}

}

运行结果：

任务过大，切割的任务： 1加到 12的和执行此任务的线程：ForkJoinPool.commonPool-worker-1

任务过大，切割的任务： 1加到 6的和执行此任务的线程：ForkJoinPool.commonPool-worker-2

任务过大，切割的任务： 7加到 12的和执行此任务的线程：ForkJoinPool.commonPool-worker-3

执行计算任务，计算 1到 3的和，结果是：6 执行此任务的线程：ForkJoinPool.commonPool-worker-2

执行计算任务，计算 4到 6的和，结果是：15 执行此任务的线程：ForkJoinPool.commonPool-worker-1

执行计算任务，计算 7到 9的和，结果是：24 执行此任务的线程：ForkJoinPool.commonPool-worker-3

执行计算任务，计算 10到 12的和，结果是：33 执行此任务的线程：ForkJoinPool.commonPool-worker-1

78

注意执行任务的线程名称：commonPool表示执行任务的线程是公用的ForkJoinPooL线程池中的线程，上面的例子中，并没有创建一个新的ForKJoinPool线程池

3.2 join( ) 等待任务的完成

 public final V join() {

        int s;

        if ((s = doJoin() & DONE_MASK) != NORMAL)

            reportException(s);

        return getRawResult();//直接返回结果

    }

重点在 dojoin() 方法，下面追踪下去

 private int doJoin() {

        int s; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;

        return

            //如果完成，直接返回s

            (s = status) < 0 ? s :

            //没有完成，判断是不是池中的 ForkJoinWorkerThread 工作线程

            ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?

            //如果是池中线程，执行这里

            (w = (wt = (ForkJoinWorkerThread)t).workQueue).

            tryUnpush(this) && (s = doExec()) < 0 ? s :

            wt.pool.awaitJoin(w, this, 0L) :

            //如果不是池中的线程池，则执行这里

            externalAwaitDone();

    }

仔细看上面的注释。当 dojoin( )方法发现任务没有完成且当前线程是池中线程时，执行了 tryUnpush( )方法。tryUnpush()方法尝试去执行此任务：如果要join的任务正好在当前任务队列的顶端，那么pop出这个任务，然后调用 doExec() 让当前线程去执行这个任务。

 final boolean tryUnpush(ForkJoinTask<?> t) {

            ForkJoinTask<?>[] a; int s;

            if ((a = array) != null && (s = top) != base &&

                U.compareAndSwapObject

                (a, (((a.length - 1) & --s) << ASHIFT) + ABASE, t, null)) {

                U.putOrderedInt(this, QTOP, s);

                return true;

            }

            return false;

        }

 final int doExec() {

        int s; boolean completed;

        if ((s = status) >= 0) {

            try {

                completed = exec();

            } catch (Throwable rex) {

                return setExceptionalCompletion(rex);

            }

            if (completed)

                s = setCompletion(NORMAL);

        }

        return s;

    }

如果任务不是处于队列的顶端，那么就会执行 awaitJoin( ) 方法。

 /**

     * Helps and/or blocks until the given task is done or timeout.

     *

     * @param w caller

     * @param task the task

     * @param deadline for timed waits, if nonzero

     * @return task status on exit

     */

    final int awaitJoin(WorkQueue w, ForkJoinTask<?> task, long deadline) {

        int s = 0;

        if (task != null && w != null) {

            ForkJoinTask<?> prevJoin = w.currentJoin;

            U.putOrderedObject(w, QCURRENTJOIN, task);

            CountedCompleter<?> cc = (task instanceof CountedCompleter) ?

                (CountedCompleter<?>)task : null;

            for (;;) {

                if ((s = task.status) < 0)//如果任务完成了，跳出死循环

                    break;

                if (cc != null)//当前任务是CountedCompleter类型，则尝试从任务队列中获取当前任务的派生子任务来执行；

                    helpComplete(w, cc, 0);

                else if (w.base == w.top || w.tryRemoveAndExec(task))//如果当前线程的内部队列为空，或者成功完成了任务，帮助某个线程完成任务。

                    helpStealer(w, task);

                if ((s = task.status) < 0)//任务完成，跳出死循环

                    break;

                long ms, ns;

                if (deadline == 0L)

                    ms = 0L;

                else if ((ns = deadline - System.nanoTime()) <= 0L)

                    break;

                else if ((ms = TimeUnit.NANOSECONDS.toMillis(ns)) <= 0L)

                    ms = 1L;

                if (tryCompensate(w)) {

                    task.internalWait(ms);

                    U.getAndAddLong(this, CTL, AC_UNIT);

                }

            }

            U.putOrderedObject(w, QCURRENTJOIN, prevJoin);

        }

        return s;

    }

重点说一下helpStealer。helpStealer的原则是你帮助我执行任务,我也帮你执行任务。

遍历奇数下标,如果发现队列对象currentSteal放置的刚好是自己要找的任务,则说明自己的任务被该队列A的owner线程偷来执行
如果队列A队列中有任务，则从队尾(base)取出执行；
如果发现队列A队列为空，则根据它正在join的任务,在拓扑找到相关的队列B去偷取任务执行。

在执行的过程中要注意，我们应该完整的把任务完成

还有剩下的几个比较核心的部分源码就不再此处分析，提供两个比较棒的博文：（因为我还有一些疑惑没解决，以后再补充）

最后，有兴趣的还可以看一下Doug Lea 的写的Fork-Join 框架的文章

原文：A Java Fork/Join Framework

中文译文：Fork/Join 框架-设计与实现

参考文献：

PunyGod https://www.jianshu.com/p/f777abb7b251