在Java的ForkJoinTask中，fork/join的顺序重要吗？

Question

假设我们扩展了一个名为＜code＞MyRecursiveTask。

然后在 forkJoinTask 的范围内创建两个子任务：

MyRecursiveTask t1 = new MyRecursiveTask()
MyRecursiveTask t2 = new MyRecursiveTask()
t1.fork()
t2.fork()

我认为“t2”将位于工作队列的顶部(这是一个deque，它被用作worker本身的堆栈)，因为我看到fork方法的实现如下:

public final ForkJoinTask<V> fork() {
    Thread t;
    if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
        ((ForkJoinWorkerThread)t).workQueue.push(this);
    else
        ForkJoinPool.common.externalPush(this);
    return this;
}

如果是，以下两个表达式的性能是否存在差异：

表达式1：

t1.join() + t2.join()

表达式 2：

t2.join() + t1.join()

我认为这可能很重要t1.join（）在＜code>t2.join（）完成之前将始终处于阻塞状态（如果没有工作窃取），因为只有工作队列顶部的任务才能被弹出。（换句话说，t2必须在t1被弹出之前被弹出）。下面是＜code＞doJoin

private int doJoin() {
    int s; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;
    return (s = status) < 0 ? s :
        ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?
        (w = (wt = (ForkJoinWorkerThread)t).workQueue).
        tryUnpush(this) && (s = doExec()) < 0 ? s :
        wt.pool.awaitJoin(w, this, 0L) :
        externalAwaitDone();
}

/**
 * Pops the given task only if it is at the current top.
 * (A shared version is available only via FJP.tryExternalUnpush)
*/
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;
}

有人对此有想法吗？谢谢

Answer 1

如果有足够的内核数，那么两个线程并行运行，先启动哪一个并不重要，因为竞争时间很重要。因此，无论谁先完成，都必须等待另一个完成并计算结果。如果您只有一个内核，那么您的想法可能是正确的，但是对于一个内核，您为什么需要并行化作业呢？

Answer 2

无论您使用Java7还是Java8都很重要。在Java7中，框架为join（）创建延续线程。在Java8中，框架主要为join（）暂停。请参阅此处。自2010年以来，我一直在写一篇关于这个框架的评论。

使用RecursiveTask的建议(来自JavaDoc):

return f2.compute() + f1.join();

这样，拆分线程将继续操作本身。

不推荐依靠F/J代码来指引方向，因为这种代码经常变化。例如，在Java8中使用嵌套的并行流导致了太多的补偿线程，以至于在Java8u40中重新编写了代码，结果导致了更多的问题。看这里。

如果必须执行多个连接，那么连接（）的顺序实际上并不重要。每个fork（）使任务可用于任何线程。