java forkjoin 简书_Java并发编程之Fork Join框架

1. 什么是Fork/Join框架

Fork/Join框架是Java7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。

我们再通过Fork和Join这两个单词来理解一下Fork/Join框架。Fork就是把一个大任务切分 为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。比如计算1+2+…+10000，可以分割成10个子任务，每个子任务分别对1000个数进行求和，最终汇总这10个子任务的结果。

Fork/Join的运行流程如图所示:

Fork Join运行流程

2. 工作窃取算法

工作窃取(work-stealing)算法是指某个线程从其他队列里窃取任务来执行。那么，为什么 需要使用工作窃取算法呢？假如我们需要做一个比较大的任务，可以把这个任务分割为若干 互不依赖的子任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应。比如A线程负责处理A队列里的任务。但是，有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿 任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

工作窃取算法的优点：充分利用线程进行并行计算，减少了线程间的竞争。

工作窃取算法的缺点：在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且该算法会消耗了更多的系统资源，比如创建多个线程和多个双端队列。

3. Fork/Join框架的设计

我们已经很清楚Fork/Join框架的需求了，那么可以思考一下，如果让我们来设计一个 Fork/Join框架，该如何设计？这个思考有助于你理解Fork/Join框架的设计。

步骤1 分割任务。首先我们需要有一个fork类来把大任务分割成子任务，有可能子任务还是很大，所以还需要不停地分割，直到分割出的子任务足够小。

步骤2 执行任务并合并结果。分割的子任务分别放在双端队列里，然后几个启动线程分 别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里，启动一个线程从队列里拿数据，然后合并这些数据。

Fork/Join使用两个类来完成以上两件事情。

①ForkJoinTask：我们要使用ForkJoin框架，必须首先创建一个ForkJoin任务。它提供在任务 中执行fork()和join()操作的机制。通常情况下，我们不需要直接继承ForkJoinTask类，只需要继承它的子类，Fork/Join框架提供了以下两个子类。

RecursiveAction：用于没有返回结果的任务

RecursiveTask：用于有返回结果的任务

②ForkJoinPool：ForkJoinTask需要通过ForkJoinPool来执行。

任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当 一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

4. 使用Fork/Join框架

让我们通过一个简单的需求来使用Fork/Join框架，需求是：计算1+2+3+4的结果。

使用Fork/Join框架首先要考虑到的是如何分割任务，如果希望每个子任务最多执行两个 数的相加，那么我们设置分割的阈值是2，由于是4个数字相加，所以Fork/Join框架会把这个任 务fork成两个子任务，子任务一负责计算1+2，子任务二负责计算3+4，然后再join两个子任务的结果。因为是有结果的任务，所以必须继承RecursiveTask，实现代码如下:

package ForkJoin;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.RecursiveTask;

public class CountTask extends RecursiveTask {

private static final int THRESHOLD = 2; //阈值

private int start;

private int end;

public CountTask(int start, int end) {

this.start = start;

this.end = end;

}

@Override

protected Integer compute() {

int sum = 0;

boolean canCompute = (end - start) <= THRESHOLD;

if (canCompute){

for (int i = start; i <= end ; i++) {

sum +=i;

}

}else {

//如果任务大于阈值，就分裂成两个子任务计算

int middle = (start + end) / 2;

CountTask leftTask = new CountTask(start, middle);

CountTask rightTask = new CountTask(middle+1, end);

// 执行子任务

leftTask.fork();

rightTask.fork();

// 等待子任务执行完，并得到其结果

int leftResult = leftTask.join();

int rightResult = rightTask.join();

// 合并子任务

sum = leftResult + rightResult;

}

return sum;

}

public static void main(String[] args) {

ForkJoinPool forkJoinPool = new ForkJoinPool();

// 生成一个计算任务，负责计算1+2+3+4

CountTask countTask = new CountTask(1,4);

Future result = forkJoinPool.submit(countTask);

try {

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

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

}

}

4. 原理

4.1 构造函数

private ForkJoinPool(int parallelism,

ForkJoinWorkerThreadFactory factory,

UncaughtExceptionHandler handler,

int mode,

String workerNamePrefix) {

this.workerNamePrefix = workerNamePrefix;

this.factory = factory;

this.ueh = handler;

this.config = (parallelism & SMASK) | mode;

long np = (long)(-parallelism); // offset ctl counts

this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);

}

重要参数解释:

parallelism：并行度( the parallelism level)，默认情况下跟我们机器的cpu个数保持一致，使用 Runtime.getRuntime().availableProcessors()可以得到我们机器运行时可用的CPU个数。

factory：创建新线程的工厂( the factory for creating new threads)。默认情况下使用 ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory。

handler：线程异常情况下的处理器(Thread.UncaughtExceptionHandler handler)，该处理器在线程执行任务时由于某些无法预料 到的错误而导致任务线程中断时进行一些处理，默认情况为null。

asyncMode：这个参数要注意，在ForkJoinPool中，每一个工作线程都有一个独立的任务队列，asyncMode表示工作线程内的任务队 列是采用何种方式进行调度，可以是先进先出FIFO，也可以是后进先出LIFO。如果为true，则线程池中的工作线程则使用先进先出方式 进行任务调度，默认情况下是false。

4.2 方法

4.2.1 ForkJoinTask fork方法

fork() 做的工作只有一件事，既是把任务推入当前工作线程的工作队列里。可以参看以下的源代码:

public final ForkJoinTask fork() {

Thread t;

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

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

else

ForkJoinPool.common.externalPush(this);

return this;

}

4.2.2 ForkJoinTask join方法

join() 的工作则复杂得多，也是join()可以使得线程免于被阻塞的原因——不像同名的Thread.join()。

检查调用 join() 的线程是否是ForkJoinThread线程。如果不是(例如 main 线程)，则阻塞当前线程，等待任务完成。如果是，则不阻塞。

查看任务的完成状态，如果已经完成，直接返回结果。

如果任务尚未完成，但处于自己的工作队列内，则完成它。

如果任务已经被其他的工作线程偷走，则窃取这个小偷的工作队列内的任务(以 FIFO方式)，执行，以期帮助它早日完成欲 join 的任务。

如果偷走任务的小偷也已经把自己的任务全部做完，正在等待需要 join 的任务时，则找到小偷的小偷，帮助它完成它的任务。

递归地执行第5步。

4.2.3 ForkJoinPool.submit方法

ForkJoinPool 自身拥有工作队列，这些工作队列的作用是用来接收由外部线程(非 ForkJoinThread 线程)提交过来的任务，而这些工作 队列被称为 submitting queue 。 submit() 和 fork() 其实没有本质区别，只是提交对象变成了 submitting queue 而已(还有一些同步，初始化的操作)。submitting queue 和其他 work queue 一样，是工作线程”窃取“的对象，因此当其中的任务被一个工作线程成功窃取时，就意味着提交的任务真正 开始进入执行阶段。

public ForkJoinTask submit(ForkJoinTask task) {

if (task == null)

throw new NullPointerException();

externalPush(task);

return task;

}

4.3 Fork/Join框架执行流程

ForkJoinPool 中的任务执行分两种:

直接通过 FJP 提交的外部任务(external/submissions task)，存放在 workQueues 的偶数槽位；

通过内部 fork 分割的子任务(Worker task)，存放在 workQueues 的奇数槽位。

Fork/Join框架执行流程

参考资料

《Java并发编程的艺术》