一、什么是ForkJion

　　Fork/Join框架是Java7提供的并行执行任务框架，思想是将大任务分解成小任务，然后小任务又可以继续分解，然后每个小任务分别计算出结果再合并起来，最后将汇总的结果作为大任务结果。其思想和MapReduce的思想非常类似。对于任务的分割，要求各个子任务之间相互独立，能够并行独立地执行任务，互相之间不影响。

二、运行流程图（侵删）：

　　

三、特点：

　　工作窃取-----ForkJion里面是一个双端队列，当A线程运行完自己的任务后，如果B线程没完成，就去B线程的另一端去一个任务来完成

四、核心类

• ForkJoinPool

  　　　　ForkJoinPool是ForkJoin框架中的任务调度器，和ThreadPoolExecutor一样实现了自己的线程池，提供了三种调度子任务的方法：

• ForkJoinTask

  　　　　Fork/Join框架中的实际的执行任务类，有以下两种实现，一般继承这两种实现类即可。

五、代码实现

　　实现1+2+3+…+10亿的和

package com.jenne.juc.forkjion;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
* 1、forkjoinPool 通过它来执行
* 2、计算任务 forkjoinPool.execute(ForkJoinTask task)
* 3、计算类要继承 ForkJoinTask及其子类
*/

//运行类
public class Demo {

public static void main(String\[\] args) throws ExecutionException, InterruptedException {  
    test2();  
}

// 一般操作  
public static void test1() {  
    Long sum = 0L;  
    long start = System.currentTimeMillis();  
    for (Long i = 1L; i <= 10\_0000\_0000; i++) {  
        sum += i;  
    }  
    long end = System.currentTimeMillis();  
    System.out.println("sum=" + sum + " 时间：" + (end - start));  
}

// 使用ForkJoin  
public static void test2() throws ExecutionException, InterruptedException {  
    long start = System.currentTimeMillis();  
    ForkJoinPool forkJoinPool = new ForkJoinPool();  
    ForkJoinTask<Long> task = new ForkJoinTaskDemo(0L, 10\_0000\_0000L);  
    ForkJoinTask<Long> submit = forkJoinPool.submit(task);// 提交任务  
    Long sum = submit.get();  
    long end = System.currentTimeMillis();  
    System.out.println("sum=" + sum + " 时间：" + (end - start));  
}

//Stream并行流  
public static void test3() {  
    long start = System.currentTimeMillis();  
    // Stream并行流() (\]  
    long sum = LongStream.rangeClosed(0L, 10\_0000\_0000L).parallel().reduce(0, Long::sum);  
    long end = System.currentTimeMillis();  
    System.out.println("sum=" + "时间：" + (end - start));  
}

}

//计算类
class ForkJoinTaskDemo extends RecursiveTask {
private Long start; // 1
private Long end; // 1990900000
// 临界值
private Long temp = 10000L;

public ForkJoinTaskDemo(Long start, Long end) {  
    this.start = start;  
    this.end = end;  
}

// 计算方法  
@Override  
protected Long compute() {  
    if ((end - start) < temp) {  
        Long sum = 0L;  
        for (Long i = start; i <= end; i++) {  
            sum += i;  
        }  
        return sum;  
    } else { // forkjoin 递归  
        long middle = (start + end) / 2; // 中间值  
        ForkJoinTaskDemo task1 = new ForkJoinTaskDemo(start, middle);  
        task1.fork(); // 拆分任务，把任务压入线程队列  
        ForkJoinTaskDemo task2 = new ForkJoinTaskDemo(middle + 1, end);  
        task2.fork(); // 拆分任务，把任务压入线程队列  
        return task1.join() + task2.join();  
    }  
}  

}