Fork/join计算大量数据的和&&使用stream()的并行流的方法计算和

Fork/join的思想简单概括为8个字：分而治之 工作窃取
大的任务被细分给多个线程解决， 工作窃取是一个线程解决自己的任务后可以去获取别的线程未解决的工作去解决
fork/join 很大层度使用的递归算法做核心实现

看代码 注释都在代码里面

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo extends RecursiveTask {
    private long start;
    private long end;
    private final long THREADHOLD = 10000L;

    public ForkJoinDemo() {
    }

    public ForkJoinDemo(long start, long end) {
        this.start = start;
        this.end = end;
    }

    public static void main(String[] args) {
        Instant start = Instant.now();
        //  30_0000_0000用这种方法来表明极大的数更清晰简洁
        // 就是三步   ForkJoinTask  -->  ForkJoinPool  --> task提交给pool
        ForkJoinTask forkJoinTask = new ForkJoinDemo(0L,30_0000_0000L);
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask t = pool.submit(forkJoinTask); //这个方法30多毫秒 submit这个方法很常见，就是异步提交
//        Long t = pool.invoke(forkJoinTask);  //这个方法0.8s
        System.out.println(t);
        Instant end= Instant.now();  //这种计算时间的方法很好
        System.out.println(Duration.between(start,end));
    }

    @Override
    protected Long compute() {
        //范围不大的时候  for循环更迅速
        if(end-start< THREADHOLD) {
            long sum = 0;
            for(long i=start;i 
相比for循环计算极大提高效率，注释当for不使用包装类速度也快（java保留基本数据类型就是为提高运算速度），使用包装类会极大降低速度，因为包装类 就是对象，存储在堆里面。但很多场景我们不能使用基本数据类型，而不得不使用包装类Long，Integer等。
 
接下来是 使用STREAM()的并行流的方法 
```java

public class ForkJoinTest {
    public static void main(String[] args) {
//        test1();
//        test2();
        test3();
    }

    public static void test1() {
        Long sum=0L;
        long time = System.currentTimeMillis();
        for(Long i=0L;i < 30_0000_0000L;i++) {
            sum+=i;
        }
        System.out.println(sum+"       "+  (System.currentTimeMillis()-time));
    }
    public static void test2() {
        long sum=0;
        long time = System.currentTimeMillis();
//        sum= LongStream.rangeClosed(0,10_0000_0000).parallel().sum();
        sum = LongStream.rangeClosed(0L, 30_0000_0000L).parallel().reduce(0, Long::sum);
        System.out.println(sum+"       "+  (System.currentTimeMillis()-time));
    }
    public static void test3() {
        Instant start = Instant.now();
        long sum = LongStream.rangeClosed(0L,30_0000_0000L).reduce(0,Long::sum);
        Instant end = Instant.now();
        System.out.println(sum);
        System.out.println("duration ="+ Duration.between(start,end));
        long sum2 = LongStream.rangeClosed(0L,30_0000_0000L).parallel().reduce(0,(x,y)->x+y);
//        long sum2 = LongStream.rangeClosed(0L,30_0000_0000L).parallel().reduce(0,Long::sum);
        Instant end2 = Instant.now();
        System.out.println(sum2);
        System.out.println("duration = "+ Duration.between(end,end2));
        //从结果可以看出，加了parallel（并行流）的计算的更快差距是十几倍

    }
}
// 10亿时
// test1 与 test2 都使用long类型时，test2使用并行流时间约为test1的一半，200毫秒
// 当使用long的包装类Long的时候，test1的时间11s,我去，包装类计算耗时间太多了
// 当使用Long的时候，test2的时间几乎不变
 
for循环 可以看做串行流，并行流能极大提高运算速度。