Java 8 parallelStream 与Stream 比较

java8 parallelStream 与Stream 都是将集合转换为流，parallelStream 是并行流，Stream 是串行流

1. 并不是所有大数据量流操作parallelStream 要比Stream 快，如下两个例子

List<Integer>  intList1 = new ArrayList<>();
        for(int i=0;i<=10000000;i++){
            intList1.add(i);
        }
        System.out.println("开始并行筛选"+ DateUtilByJoda.format(new Date(), DateUtilByJoda.NORM_DATETIME_PATTERN));
        List<Integer>  m= intList1.parallelStream().filter(a->a%2==0).collect(Collectors.toList());
        System.out.println("开始并行筛选"+ DateUtilByJoda.format(new Date(), DateUtilByJoda.NORM_DATETIME_PATTERN));

        List<Integer>  intList2 = new ArrayList<>();
        for(int i=10000000;i<=20000000;i++){
            intList2.add(i);
        }
        System.out.println("开始筛选"+DateUtilByJoda.format(new Date(), DateUtilByJoda.NORM_DATETIME_PATTERN));
        List<Integer>  n = intList2.stream().filter(a->a%2==0).collect(Collectors.toList());
        System.out.println("开始筛选"+DateUtilByJoda.format(new Date(), DateUtilByJoda.NORM_DATETIME_PATTERN));

执行结果 开始并行筛选2021-07-15 19:38:54 开始并行筛选2021-07-15 19:38:57 开始筛选2021-07-15 19:38:58 开始筛选2021-07-15 19:38:58

结果显示 strem 反而比parallelStream 快了好几倍

修改之后

List<Integer>  intList1 = new ArrayList<>();
        for(int i=0;i<=100000;i++){
            intList1.add(i);
        }
        long start = System.currentTimeMillis();
        List<Integer>  m= intList1.parallelStream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                try {
                    Thread.sleep(1);
                    return  integer%2==0;
                } catch (InterruptedException e) {
                    return false;
                }
            }
        }).collect(Collectors.toList());
        System.out.println("交易耗时："+(System.currentTimeMillis()-start));

        List<Integer>  intList2 = new ArrayList<>();
        for(int i=100000;i<=200000;i++){
            intList2.add(i);
        }
        start= System.currentTimeMillis();
        List<Integer>  n = intList2.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                try {
                    Thread.sleep(1);
                    return  integer%2==0;
                } catch (InterruptedException e) {
                    return false;
                }
            }
        }).collect(Collectors.toList());
        System.out.println("交易耗时："+(System.currentTimeMillis()-start));

输出结果

交易耗时：21714 交易耗时：172628

parallelStream比Stream 快了好几倍

2. parallelStream 使用场景

1. 每个操作处理比较耗时（如上 睡眠1毫秒要比 直接a%==2 耗时）。
2. 每个元素的操作不存在上下级的依赖关系。
3. parallelStream 使用时要注意会有线程安全问题（后续会讲到）