Fork/Join框架 组成成分 与 代码示例
JDK1.7推出，用于并行执行任务：将一个大人物分割成若干小任务，最终汇总每个小任务的结果得到大任务的结果。
主要分两步：任务分割；结果合并。
API介绍：
(1)ForkJoinPool：线程池
(2)ForkJoinTask：任务，即自定义一个任务类，继承RecursiveAction\RecursiveTask，重写compute()方法
ForkJoinTask中的主要方法：
* fork() 在当前线程运行的线程池中安排一个异步执行。简单的理解就是再创建一个子任务。
* join() 当任务完成的时候返回计算结果。
* invoke() 开始执行任务，如果必要，等待计算完成。
子类：
* RecursiveAction 一个递归无结果的ForkJoinTask（没有返回值）
* RecursiveTask 一个递归有结果的ForkJoinTask（有返回值）
(3)ForkJoinWorkerThread：线程池中一个执行任务的线程
Executor框架中学习的线程池 和 ForkJoin框架中的ForkJoinPool的区别：
ForkJoinPool线程池中每个线程都单独拥有一个工作队列，当自己队列中的任务都完成后，该线程会从其他线程的工作队列中窃取一个任务执行(窃取是Fork/Join框架与Executor框架中线程池的最主要区别，另一个是队列，下面跟着会讲队列)，这样可以充分利用线程进行并行计算，利用空闲时间，充分利用资源。
当A线程去B线程的队列中窃取任务时（某任务在B线程的队列中，说明这个任务已经分配给B线程了，A这时想偷过来），A B可能同时访问该同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常工作队列使用的是双端队列，被窃取任务线程永远从队头拿任务，窃取任务线程永远从队尾拿任务，减少了线程间竞争，缺点是在某些情况下还是存在竞争，比如双端队列中只有一个任务，另外也消耗了更多资源（多个队列，且还是双端队列）。
（此处ForkJoinPool线程池中线程与队列的关系 与 Executor框架中ThreadPoolExecutor线程池中线程与阻塞队列（BlockingQueue）的关系有很大不同，
Executor框架中是所用线程共用一个工作队列（堵塞队列），所有线程都从这个工作队列中取任务）
而ForkJoinPool：
使用一种分治算法，递归地将任务分割成更小的子任务，其中阈值可配置，然后把子任务分配给不同的线程执行并发执行，最后再把结果组合起来。该用法常见于数组与集合的运算。
由于提交的任务不一定能够递归地分割成ForkJoinTask，且ForkJoinTask执行时间不等长，所以ForkJoinPool使用一种工作窃取的算法，允许空闲的线程“窃取”分配给另一个线程的工作。由于工作无法平均分配并执行。所以工作窃取算法能更高效地利用硬件资源。
总结一下，这么记：正常的都是一般线程池共用一个阻塞队列，线程数达到核心线程时，就往阻塞队列里让任务......
而fork/join框架为了任务窃取这么一个东西，就需要每个线程维护一个阻塞队列。
从前面知道了线程池和工作队列的关系，从源码角度来看，WorkQueue是ForkJoinPool的内部类，WorkQueue是线程池中线程的工作队列的一个封装，支持任务窃取
和Executor框架一样，由线程池调用execute()/submit()方法，提交任务到当前提交者的任务队列中。
execute()不返回结果，submit()返回结果。
注意：（Executor框架的上面两个方法的参数是线程，而Fork/Join框架的上面两个方法的参数是自定义task任务（即继承了RecursiveAction或RecursiveTask的自定义类）） 感觉这句话不太对？？正解：参数都是自定义任务，而非线程
ForkJoinWorkerThread类中有所在线程池和对应的工作队列的引用，靠两个引用将三者联系在一起：
public class ForkJoinWorkerThread extends Thread {
......
// the pool this thread works in
final ForkJoinPool pool;
// work-stealing mechanics
final ForkJoinPool.WorkQueue workQueue;
......
}
demo1：批量发送消息
无返回
//在compute()中直接用invokeAll()，而没有用fork() （和返不返回没关系）
public class ForkJoinPoolDemo {
class SendMsgTask extends RecursiveAction {
private final int THRESHOLD = 10;
private int start;
private int end;
private List list;
public SendMsgTask(int start, int end, List list) {
this.start = start;
this.end = end;
this.list = list;
}
@Override
protected void compute() {
if ((end - start) <= THRESHOLD) {
for (int i = start; i < end; i++) {
System.out.println(Thread.currentThread().getName() + ": " + list.get(i));
}
}else {
int middle = (start + end) / 2;
invokeAll(new SendMsgTask(start, middle, list), new SendMsgTask(middle, end, list)); //这行代码可以理解成left.fork() 和 right.fork()
}
}
}
public static void main(String[] args) throws InterruptedException {
List list = new ArrayList<>();
for (int i = 0; i < 123; i++) {
list.add(String.valueOf(i+1));
}
ForkJoinPool pool = new ForkJoinPool();
pool.execute(new ForkJoinPoolDemo().new SendMsgTask(0, list.size(), list)); //经实验，submit也可以 （因为只有execute不能和Callable(即有返回值的)匹配）
pool.awaitTermination(10, TimeUnit.SECONDS);
pool.shutdown();
}
}
demo2：求和
有返回
//在compute()中使用fork+ return join （和返不返回没关系）
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
public class ForkJoinTaskDemo {
private class SumTask extends RecursiveTask {
private static final int THRESHOLD = 20;
private int arr[];
private int start;
private int end;
public SumTask(int[] arr, int start, int end) {
this.arr = arr;
this.start = start;
this.end = end;
}
/**
* 小计
*/
private Integer subtotal() {
Integer sum = 0; //注意，sum是定义在compute()方法里，而非自定义任务的成员变量里的
for (int i = start; i < end; i++) {
sum += arr[i];
}
System.out.println(Thread.currentThread().getName() + ": ∑(" + start + "~" + end + ")=" + sum);
return sum;
}
@Override
protected Integer compute() {
if ((end - start) <= THRESHOLD) {
return subtotal();
}else {
int middle = (start + end) / 2;
SumTask left = new SumTask(arr, start, middle);
SumTask right = new SumTask(arr, middle, end);
//下面两行代码可以理解成invokeAll(left,right)
left.fork();
right.fork();
return left.join() + right.join();
//换一种写法
invokeAll(left,right);
Integer left = left.join();
Integer right = right.join();
return left + right;
}
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
int[] arr = new int[100];
for (int i = 0; i < 100; i++) {
arr[i] = i + 1;
}
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask result = pool.submit(new ForkJoinTaskDemo().new SumTask(arr, 0, arr.length));
/*
1. execute(ForkJoinTask) 异步执行tasks，无返回值
2. submit(ForkJoinTask) 异步执行，且带Task返回值，可通过task.get 实现同步到主线程
3. invoke(ForkJoinTask) 有Join, tasks会被同步到主进程
*/
System.out.println("最终计算结果: " + result.invoke());
pool.shutdown();
}
}
讲一下需要用户自定义的任务类Test：
ForkJoinTask是个抽象类，用户无须直接继承该类，可以根据compute()方法是否返回值，继承ForkJoinTask的抽象子类RecursiveAction 或 RecursiveTask
ForkJoinTask出现在当forkJoinPool线程池执行继承自RecursiveTask（即有返回的）任务后，作为返回数据存在：
ForkJoinTask
private static class SumTask extends RecursiveTask {
private int threshold ;
private static final int segmentation = 10;
private int[] src;
private int fromIndex;
private int toIndex;
public SumTask(int formIndex,int toIndex,int[] src){
this.fromIndex = formIndex;
this.toIndex = toIndex;
this.src = src;
this.threshold = src.length/segmentation;
}
@Override
protected Integer compute() {
if((toIndex - fromIndex)left.fork();
right.fork();
//或 invokeAll(left,right);
return left.join()+right.join();
在main()方法里：
pool.execute(action);
/*
或 ForkJoinTask result = pool.submit(task);
result.invoke(); //get()也可以
*/
自己写的代码
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
/*
计算1+2+...+1000，并输出结果。
设置阈值为10，即把求和分为100个子任务。
*/
public class SumTask extends RecursiveTask {
private static final int THRESHOLD = 2;
private int start;
private int end;
// private int arr[];
public SumTask(int start, int end){
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
int sum = 0;
if (end - start <= THRESHOLD){
for (int i = start;i result = forkJoinPool.submit(sumTask);
System.out.println(result.get());
}
}