需求：使用Fork/Join计算1-10000的和，当一个任务的计算数量大于3000时拆分任务，数量小于3000时计算。
    image.png

    image.png
    image.png

    1. package com.itheima.demo05stream;
    3. import java.util.concurrent.ForkJoinPool;
    4. import java.util.concurrent.RecursiveTask;
    6. public class Demo08ForkJoin {
    7.     public static void main(String[] args) {
    8.         long start = System.currentTimeMillis();
    9.         ForkJoinPool pool = new ForkJoinPool();
    10.         SumRecursiveTask task = new SumRecursiveTask(1, 99999999999L);
    11.         Long result = pool.invoke(task);
    12.         System.out.println("result = " + result);
    13.         long end = System.currentTimeMillis();
    14.         System.out.println("消耗时间: " + (end - start));
    15.     }
    16. }
    18. // 1.创建一个求和的任务
    19. // RecursiveTask: 一个任务
    20. class SumRecursiveTask extends RecursiveTask<Long> {
    21.     // 是否要拆分的临界值
    22.     private static final long THRESHOLD = 3000L;
    23.     // 起始值
    24.     private final long start;
    25.     // 结束值
    26.     private final long end;
    28.     public SumRecursiveTask(long start, long end) {
    29.         this.start = start;
    30.         this.end = end;
    31.     }
    33.     @Override
    34.     protected Long compute() {
    35.         long length = end - start;
    36.         if (length < THRESHOLD) {
    37.             // 计算
    38.             long sum = 0;
    39.             for (long i = start; i <= end; i++) {
    40.                 sum += i;
    41.             }
    42.             return sum;
    43.         } else {
    44.             // 拆分
    45.             long middle = (start + end) / 2;
    46.             SumRecursiveTask left = new SumRecursiveTask(start, middle);
    47.             left.fork();
    48.             SumRecursiveTask right = new SumRecursiveTask(middle + 1, end);
    49.             right.fork();
    51.             return left.join() + right.join();
    52.         }
    53.     }
    54. }

    小结

    1. parallelStream是线程不安全的
    2. parallelStream适用的场景是CPU密集型的，只是做到别浪费CPU，假如本身电脑CPU的负载很大，那还到处用 并行流，那并不能起到作用
    3. I/O密集型 磁盘I/O、网络I/O都属于I/O操作，这部分操作是较少消耗CPU资源，一般并行流中不适用于I/O密集 型的操作，就比如使用并流行进行大批量的消息推送，涉及到了大量I/O，使用并行流反而慢了很多
    4. 在使用并行流的时候是无法保证元素的顺序的，也就是即使你用了同步集合也只能保证元素都正确但无法保证
    其中的顺序