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亲笔。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值