JAVA并行流ForkJoin框架

ForkJoin

什么是 ForkJoin

是一个分而治之的任务框架，如一个任务需要多线程执行，分割成很多块计算的时候，可以采用这种方法。
动态规范：和分而治之不同的是，每个小任务之间互相联系。

简单的说，ForkJoin 在 JDK 1.7 ， 并行执行任务！提高效率。大数据量！其中用到了并行任务的工作特点：工作窃取

原理简单的理解就是 ：分割了每个任务之后，某个线程提前完成了任务，就会去其他线程偷取任务来完成，加快执行效率。同时，第一个分配的线程是从队列中的头部拿任务，当完成任务的线程去其他队列拿任务的时候是从尾部拿任务，所以这样就避免了竞争。

这里简单写了一个简单的继承类：开发的时候可以设置临界值，小于临界值的时候，可以采用普通for循环，大于的时候采用ForkJoin框架，提高效率

/**
 * 求和计算的任务！
 * 3000   6000（ForkJoin）  9000（Stream并行流）
 * // 如何使用 forkjoin
 * // 1、forkjoinPool 通过它来执行
 * // 2、计算任务 forkjoinPool.execute(ForkJoinTask task)
 * // 3. 计算类要继承 ForkJoinTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start;  // 1
    private Long end;    // 1990900000

    // 临界值
    private Long temp = 10000L;

    public ForkJoinDemo(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; // 中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork(); // 拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork(); // 拆分任务，把任务压入线程队列

            return task1.join() + task2.join();
        }
    }
}

并行流

1、什么是并行流

Java并行流Parallel Streams是Java8和更高版本的一个特性，用于利用处理器的多个核心。通常，任何java代码都有一个处理流，在这里它是按顺序执行的。然而，通过使用并行流，我们可以将代码分成多个流，这些流在不同的内核上并行执行，最终的结果是各个结果的组合。然而，处理的顺序不在我们的控制之下。
因此，建议在以下情况下使用并行流：无论执行顺序如何，结果不受影响，一个元素的状态不影响另一个元素，并且数据源也不受影响。

2、使用范围

• 对Stream流使用Parallel()方法
• 对集合使用ParallelStream()

3、为什么使用并行流？

并行流的引入是为了提高程序的性能，但是选择并行流并不总是最好的选择。在某些情况下，我们需要以特定的顺序执行代码，在这些情况下，我们最好使用顺序流以牺牲性能为代价来执行任务。这两种流之间的性能差异仅在大型程序或复杂项目中才值得关注。对于小规模的项目，它甚至可能不明显。基本上，当顺序流表现不佳时，您应该考虑使用并行流。

4、例子

/**
 * 同一个任务，别人效率高你几十倍！
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//         test1(); // 12104
//         test2(); // 8105
//         test3(); // 146
    }

    // 普通程序员
    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 ForkJoinDemo(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));
    }

    //并行流写法
    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="+sum+"时间："+(end-start));
    }

}

这个例子：并行流的速度显而易见的比普通的快很多，当然具体的使用场景还需具体分析，这里详见下面的链接（Java8新特性-并行数据处理（parallel）：https://blog.csdn.net/qq_25027457/article/details/122543033），我觉得写的挺好的

5、LongStream rangeClosed()方法简单介绍

rangeClosed()Java中LongStream类的方法以1的增量步长从startInclusive到endExclusive返回一个有序的LongStream。这包括初始元素和最后一个元素。
语法：

static LongStream rangeClosed(long startInclusive, long endExclusive)

简单示例：

import java.util.stream.LongStream;

public class Demo {
   public static void main(String[] args) {
      LongStream longStream = LongStream.rangeClosed(20L, 25L);
      longStream.forEach(System.out::println);
   }
}

这篇文章是我学习的时候的简单总结，如有什么解释的不对的地方，欢迎大家批评指正，共同进步，谢谢大家！！！

参考博客：

Java并行流Parallel Streams介绍
Java8新特性-并行数据处理（parallel）