Java8 并行流与顺序流

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

什么是 Fork/Join 框架？

Fork/Join框架是 JDK 1.7 提供的一个用于并行执行任务的框架，其核心理念是把一个大任务分割成若干个小任务进行窃取执行，然后最终汇总每个小任务结果后得到大任务结果的并发框架。Fork 就是把一个大任务切分为若干子任务进行并行执行，Join 就是合并这些子任务的最终执行结果得到这个大任务的结果。

例：对1-1000亿数字进行累加。如果是单线程处理线程极低，这时候可以“使用forkjoin”。

说明：Fork/Join是在Java7中提供的一个并发执行任务的框架，使用相对复杂，所以在Java7应用并不是特别广。他的基本运行流程是：把一个大任务分解成子任务，如果子任务还不是足够小，就继续分解成子子任务，一直分解到足够小。具体要分解到有多小，你可以自己定义这个阈值。然后把这些子任务分摊给多个线程去执行，每个线程对应一个双端队列负责保存这些原子任务。这里叫“原子”任务，之所以叫原子任务，就是为了说明他们已经足够小。是经过多次的递归后的结果。

Fork/Join框架与传统线程池的区别？

Fork/Join框架采用“工作窃取”模式(work-stealing) ：指的是某个线程从其他队列里窃取任务来执行。使用的场景是一个大任务拆分成多个小任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列中，并且每个队列都有单独的线程来执行队列里的任务，线程和队列一一对应。但是会出现这样一种情况：A线程处理完了自己队列的任务，B线程的队列里还有很多任务要处理。A是一个很热情的线程，想过去帮忙，但是如果两个线程访问同一个队列，会产生竞争，所以A想了一个办法，从双端队列的尾部拿任务执行。而B线程永远是从双端队列的头部拿任务执行（任务是一个个独立的小任务），这样感觉A线程像是小偷在窃取B线程的东西一样。

工作窃取算法的流程图

相对于一般的线程池实现，Fork/Join框架的优势体现在，对其中包含的任务的处理方式上，在一般的线程池中，如果一个线程正在执行的任务由于某些原因(线程阻塞)无法继续运行，那么该线程会处于等待状态，而在Fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行，这种方式减少了线程的等待时间，提高了性能。

Fork/Join框架介绍

Fork/Join框架在 java.util.concurrent 包中定义。包含几个支持并发编程的类和接口。它的主要作用就是它简化了多线程创建的过程及其使用，并自动化了多个处理器之间的进程分配机制。这个框架中有两个概念，四个核心类：

两个概念

任务（ForkJoinTask）和 线程池（ForkJoinPool）。

四个核心类

1. ForkJoinTask<V>：这是一个抽象类。是Fork/Join任务的一个抽象，你需要继承此类，然后定义自己的计算逻辑。一个任务的创建就是通过此类中的fork()方法来实现的。这里说的任务几乎类似Thread类创建的那些普通线程，但更轻量级。因为它可以使用ForkJoinPool中少量有限的线程来管理大量的任务，所以它要比Thread类创建的线程更轻量。fork()方法异步执行任务，join方法可以一直等待到任务执行完毕。这个我们会在接下来的示例代码中也会有具体讲解。还有另外一个重要的方法就是invoke()方法，它是把fork和join两个操作合二为一成一个单独的调用。总之，主要有三个核心的方法，fork、join、invoke，要记住这三个方法分别是干什么用的。
2. ForkJoinPool：这个类线程池负责执行ForkJoinTask任务。
3. RecursiveAction：是并发包内现成的ForkJoinTask实现之一。继承自ForkJoinTask，负责处理那些不需要返回结果的任务。
4. RecursiveTask<V>：也是并发包内现成的ForkJoinTask实现之一。继承自ForkJoinTask，负责处理那些需要返回结果的任务。那么怎么记住这两个类的不通电呢？只需要记他们的最后一个单词，一个是Action，一个Task。Action本身就有点感觉是只负责执行，有去无回。

例：对一千亿的整数进行求和。

/**
 * ForkJoin拆分累加计算
 */
public class ForkJoinCalcuate extends RecursiveTask<Long> {

    private static final long serialVersionUID = 8564967208821254187L;

    private long start;
    private long end;
    private static final long THRESHOLD = 100000000L;//定义阈值(一亿) 标记什么情况下不拆分

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

    @Override
    protected Long compute() {
        long sum = 0;
        //判断任务是否足够小
        boolean canCompute = (end - start) <= THRESHOLD;
        if (canCompute) {
            //如果小于等于阈值说明不能再拆分，就进行运算
            for (long i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            //如果大于阈值，就再进行任务拆分
            long middle = (start + end) / 2;
            ForkJoinCalcuate leftTask = new ForkJoinCalcuate(start, middle);
            ForkJoinCalcuate rightTask = new ForkJoinCalcuate(middle + 1, end);
            //执行拆分子任务，同时压入线程队列
            leftTask.fork();
            rightTask.fork();
            //等待子任务执行完，并得到执行结果
            long leftResult = leftTask.join();
            long rightResult = rightTask.join();
            //合并子任务
            sum = leftResult + rightResult;
        }
        return sum;
    }
}

public class TestForkJoin {

    /**
     * ForkJoin框架计算
     */
    @Test
    public void test1() {
        //记录时间
        LocalTime start = LocalTime.now();
        //线程池负责执行ForkJoinTask任务
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        //0 到 一千亿：100000000000L 计算
        ForkJoinTask<Long> forkJoinCalcuate = new ForkJoinCalcuate(0, 100000000000L);//20290
        //方法一：执行给定的任务，在完成后返回其结果。
        Long result1 = forkJoinPool.invoke(forkJoinCalcuate);
        System.out.println(result1);
        LocalTime end = LocalTime.now();
        System.out.println("ForkJoin拆分计算耗费时间为：" + Duration.between(start, end).toMillis());

        //方法二：执行一个任务
        /*ForkJoinTask<Long> result2 = forkJoinPool.submit(forkJoinCalcuate);
        try {
            System.out.println(result2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }*/
    }

    /**
     * 普通计算
     */
    @Test
    public void test2() {
        //记录时间
        LocalTime start = LocalTime.now();
        long sum = 0L;
        for (long i = 0; i <= 100000000000L; i++) {
            sum += i;
        }
        System.out.println(sum);
        LocalTime end = LocalTime.now();
        System.out.println("普通计算耗费时间为：" + Duration.between(start, end).toMillis());//35813
    }
}

 注：如果数值过小计算，拆分也是需要时间(线程开销)，如果拆分时间大于单线程时间就不能用Fork/Join框架，数值越大体现的效率越高，阈值的限定也很重要。

例：对1到8进行求和。

public class CountTask extends RecursiveTask<Integer> {
    //阈值
    private static final int THRESHOLD = 2;
    private static final long serialVersionUID = 3271229736725306727L;
    private int start;
    private int end;

    @Override
    protected Integer compute() {
        //实现略
        return null;
    }
}

说明：通过继承 RecursiveTask 类，实现递归逻辑。以下是这个大任务的拆分过程，最后被拆分成了四个子任务：1+2，3+4，5+6，7+8。在拆分成这四个原子任务之前，是进行了递归fork不断拆分后才最终拆分成四个原子任务的。

上面的代码中最核心的就是compute方法，以下是compute方法的基本逻辑路程图：

进入compute方法，首先会判断当前任务的边界是否足够小，是否小于等于阈值（原子任务的大小，这个由你自己来规定）。如果足够小，则无法再进行拆分，直接for循环累加计算然后返回；如果大于阈值（这里是2），则异步fork（线程）出子任务，继续递归调用compute方法，然后执行join，等待子任务执行完毕，并得到执行结果返回。

Java8并行流

例：

    /**
     * Java8并行、顺序流
     * LongStream parallel()：返回并行流
     * LongStream sequential()：返回顺序流
     */
    @Test
    public void test3() {
        //记录时间
        LocalTime start = LocalTime.now();
        long reduce = LongStream.rangeClosed(0, 100000000000L)
                .parallel()//并行流 19755
                //.sequential()//顺序流 47799
                .reduce(0, Long::sum);
        System.out.println(reduce);
        LocalTime end = LocalTime.now();
        System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());
    }

 

转载请注明出处：BestEternity亲笔。