Java8-04-05-笔记

并行流与顺序流

1、基本定义

• 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
• Java8中将并行进行了优化，我们可以很容易的对数据进行并行操作。
• Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。

2、Fork/Join框架

• Fork/Join框架是JDK1.7提出的概念，就是在必要的情况下，将一个任务，进行拆分(fork)成若干个小任务(拆到不可再拆时)，再将一个个的小任务运算结果进行join汇总。
• Fork/Join框架与传统线程池的区别：
  采用“工作窃取”模式（work-stealing）：当执行新的任务时它可以将其拆分成更小的任务执行，并将小任务加到线程队列中，然后当某一个线程队列的任务执行完会从一个随机线程的队列中“偷”一个小任务，并把它放在自己的队列中执行。
  相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上。在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。
  而在fork/join框架实现中，如果某个子问题由于等待另一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。这种方式减少了线程的等待时间，提高了性能。
  

3、算法效率比较

package com.sunstone.stream;

public class ForkJoinCalculate exends RecursiveTask<Long>{ //RecursiveTask有返回值 RecursiveAction无返回值

    	private static final long serialVersionUID=13477720L;//数值任意提供
    	private long start;
    	private long end;
    	private  static final long THRESHOLD = 1000L;//自定义临界值

        public ForkJoinCalculate(long start, long end){//构造函数
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute(){
            long length = end - start;
            if(length <= THRESHOLD){
                long sum = 0;
                for(long i=start;i<=end;i++){
                    sum+=i;
                }
                return sum;
            }else{
                long middle =(start+end)/2;
                ForkJoinCalculate left =new ForkJoinCalculate(start, middle);
                left.fork();//拆分,并将该子任务压入线程队列
                ForkJoinCalculate right =new ForkJoinCalculate(middle+1, end);
                right.fork();//拆分,并将该子任务压入线程队列
                return left.join()+right.join();//合并
            }
        }

}

package com.sunstone.stream;

import org.junit.Test;

import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class TestForkJoin {//通过计算耗时比较，能够明显看出Java8并行流的计算速度更快

    @Test//ForkJoin框架
    public void test1() {
        long startTime = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<long> task = new ForkJoinCalculate(0L, 1000000L);
        long sum = pool.invoke(task);
        long endTime = System.currentTimeMillis();
        System.out.println("ForkJoin框架耗时：" + (endTime - startTime) + " 和：" + sum);
    }

    @Test//普通for
    public void test2() {
        long startTime = System.currentTimeMillis();
        long sum = 0;
        for (long i = 0L; i <= 1000000L; i++) {
            sum += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通for耗时：" + (endTime - startTime) + " 和：" + sum);
    }

    @Test//Java8并行流
    public void test3() {
        Instant startTime = Instant.now();
        long sum = LongStream.rangeClosed(0, 1000000L)
                .parallel()
                .reduce(0, Long::sum);
        Instant endTime = Instant.now();
        System.out.println("Java8并行流耗时：" + (endTime - startTime) + " 和：" + sum);
    }
}