Java8-11新特性总结(六) 并行数据处理与性能

       为加速数据集的处理,往往需要额外的显式优化，通过Stream来对集合中的元素执行操作流水线，以此来充分利用计算机的多个核，这意味着需要对数据进行并行处理，而在Java7之前对于集合数据执行并行处理的操作：

1、手动将数据的数据结构拆分为多个子部分。

2、分配给每个子部分一个独立的线程。

3、可能需要进行同步操作来避免竞争条件，当所有单独线程完成后进行合并。

自Java7引入"分支/合并"(Fork/Join)的框架后，则很好的解决了这个问题。

什么是Fork/Join框架？

       Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务(分为治之)，最终汇总每个小任务结果后得到大任务结果的框架。

       Fork就是把一个大任务切分为若干子任务并行的执行，Join就是合并 这些子任务的执行结果，最后得到这个大任务的结果。比如计算1+2+。。＋10000，可以分割成10个子任务，每个子任务分别对1000个数进行求和， 最终汇总这10个子任务的结果。

工作窃取算法

工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。

那么为什么需要使用工作窃取算法呢？

       假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是 把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程负责处理A队列里的任务。但是有 的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里 窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

Fork/Join框架怎么用？

ForkJoinTask：ForkJoinTask类，通常情况下只需要继承它的子类，Fork/Join框架提供了以下两个子类RecursiveAction(用于没有返回结果的任务)、RecursiveTask(用于有返回结果的任务)。Fork/Join分配的线程数量就是你的处理器数量。

ForkJoinPool：ForkJoinTask需要通过ForkJoinPool来执行，任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ForkJoinPool forkJoinPool = new ForkJoinPool();//对线程池的扩展
        Future<Integer> result = forkJoinPool.submit(new Task(1, 10000));
        System.out.println(result.get());
        forkJoinPool.shutdown();
    }
}

class Task extends RecursiveTask<Integer> {

    private int start;

    private int end;

    public Task(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        if (start - end < 100) {
            for (int i = start; i < end; i++) {
                sum += i;
            }
        } else {//间隔有100则拆分多个任务计算
            int middle = (start + end) / 2;
            Task left = new Task(start, middle);
            Task right = new Task(middle + 1, end);
            left.fork();
            right.fork();
            sum = left.join() + right.join();
        }
        return sum;
    }
}

并行流

什么是并行流？

       将工作负荷分配到多核处理器的所有核，把工作内容拆分为多个模块，使用不同线程分别去处理对应模块的数据流。

示例：

计算1-1000的数字之和：

//串行流
long start = System.currentTimeMillis();
System.out.println(Stream.iterate(1,i -> {
try {
    Thread.sleep(50L);
} catch (InterruptedException e) {
    e.printStackTrace();
}
    return i + 1;
}).limit(1000).mapToInt(Integer::intValue).sum());
System.out.println(System.currentTimeMillis() - start);    //500500

//并行流
long start01 = System.currentTimeMillis();
System.out.println(Stream.iterate(1, i -> {
try {
    Thread.sleep(50L);
} catch (InterruptedException e) {
    e.printStackTrace();
}
    return i + 1;
}).limit(1000).parallel().mapToInt(Integer::intValue).sum());
System.out.println(System.currentTimeMillis() - start01);    //63105

并行求和流程示例图：

​

       同样，我们也可以通过调用sequential将流变为顺序流或者同时使用parallel和sequential来精细控制遍历流操作的不同步骤的执行方式  。

stream.parallel() .filter(...) .sequential() .map(...) .parallel() .reduce();