个人中心
gpt4 book ai didi

Java8的Stream()与ParallelStream()的区别说明

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 35 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java8的Stream()与ParallelStream()的区别说明由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

Java8 Stream()与ParallelStream()区别

Stream

Java8的Stream()与ParallelStream()的区别说明

无状态：指元素的处理不受之前元素的影响； 。

有状态：指该操作只有拿到所有元素之后才能继续下去.

非短路操作：指必须处理所有元素才能得到最终结果； 。

短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果.

ParallelStream

对于ParallelStream，需要知道的是里面的执行是异步的，并且使用的线程池是ForkJoinPool.common，可以通过设置-Djava.util.concurrent.ForkJoinPool.common.parallelism = N来调整线程池的大小； 。

ParallelStream的作用 。

Stream具有平行处理能力，处理的过程会分而治之，也就是将一个大任务切分成多个小任务，这表示每个任务都是一个操作，因此像以下的程式片段:

?
1
2
List<Integer> numbers = Arrays.asList( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 );
numbers.parallelStream().forEach(System.out::println);

得到的展示顺序不一定会是1、2、3、4、5、6、7、8、9，而可能是任意的顺序。得到的结论就是parallelStream()每次执行的结果都不相同，与多线程程序中执行的结果类似。如果希望最后顺序是按照原来Stream的数据顺序，那可以调用forEachOrdered().

例如:

?
1
2
List<Integer> numbers = Arrays.asList( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 );
numbers.parallelStream().forEachOrdered(System.out::println);

你得到的展示顺序就是1、2、3、4、5、6、7、8、9.

Java8并行流parallelStream()和stream()的区别就是支持并行执行，提高程序运行效率。但是如果使用不当可能会发生线程安全的问题.

其他同类知识点:

1、Java集合Stream类filter的使用； 。

2、Java中的排序问题（Java8新特性 stream流、stream多字段排序）； 。

parallelStream与stream效率比较

结论

parallel线程不安全 。

parallel的效率，因为是多线程，默认线程数量是计算器处理器的数量 。

代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
public class StreamTest {
     @Test
     public void streamVs(){
         List<Integer> list1 = new ArrayList<>( 10000 );
         List<Integer> list2 = new ArrayList<>( 10000 );
         List<Integer> list3 = new ArrayList<>( 10000 );
         Lock lock = new ReentrantLock();
         IntStream.range( 0 , 10000 ).forEach(list1::add);
         IntStream.range( 0 , 10000 ).parallel().forEach(list2::add);
         IntStream.range( 0 , 10000 ).parallel().forEach(i -> {
             lock.lock();
             try {
                 list3.add(i);
             } finally {
                 lock.unlock();
             }
         });
         System.out.println( "串行执行的大小：" + list1.size());
         System.out.println( "并行执行的大小：" + list2.size());
         System.out.println( "加锁并行执行的大小：" + list3.size());
     }
     @Test
     public void streamVs2(){
         List<Person> persons = constructPersons();
         doFor(persons);
         doStream(persons);
         doParallelStream(persons);
     }
     /**
      * 构造数据
      *
      * @return
      */
     public List<Person> constructPersons() {
         List<Person> persons = new ArrayList<Person>();
         for ( int i = 0 ; i < 5 ; i++) {
             Person p = new Person(i, "name" + i, "sex" + i, i);
             persons.add(p);
         }
         return persons;
     }
     /**
      * for
      *
      * @param persons
      */
     public void doFor(List<Person> persons) {
         long start = System.currentTimeMillis();
         for (Person p : persons) {
             try {
                 Thread.sleep( 1000 );
             } catch (InterruptedException e) {
             }
             //System.out.println(p.name);
         }
         long end = System.currentTimeMillis();
         System.out.println( "doFor cost:" + (end - start));
     }
     /**
      * 顺序流
      *
      * @param persons
      */
     public void doStream(List<Person> persons) {
         long start = System.currentTimeMillis();
         persons.stream().forEach(x -> {
             try {
                 Thread.sleep( 1000 );
             } catch (InterruptedException e) {
             }
             //System.out.println(x.name);
         });
         long end = System.currentTimeMillis();
         System.out.println( "doStream cost:" + (end - start));
     }
     /**
      * 并行流
      *
      * @param persons
      */
     public void doParallelStream(List<Person> persons) {
         long start = System.currentTimeMillis();
         persons.parallelStream().forEach(x -> {
             try {
                 Thread.sleep( 1000 );
             } catch (InterruptedException e) {
             }
             //System.out.println(x.name);
         });
         long end = System.currentTimeMillis();
         System.out.println( "doParallelStream cost:" + (end - start));
     }
}
class Person {
     int    id;
     String name;
     String sex;
     float  height;
     public Person( int id, String name, String sex, float height) {
         this .id = id;
         this .name = name;
         this .sex = sex;
         this .height = height;
     }
}

测试截图 。

串行执行的大小：10000 。

并行执行的大小：7219 。

加锁并行执行的大小：10000 。

?
1
2
3
doFor cost: 5012
doStream cost: 5073
doParallelStream cost: 2013

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.

原文链接：https://blog.csdn.net/weixin_44299027/article/details/102615197 。

最后此篇关于Java8的Stream()与ParallelStream()的区别说明的文章就讲到这里了,如果你想了解更多关于Java8的Stream()与ParallelStream()的区别说明的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

35 4 0
文章推荐： Java实现消消乐中的消除功能
文章推荐： Java之Jackson使用案例详解
文章推荐： Java静态代理与动态代理案例详解
文章推荐： Java中16条的代码规范
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com