首页 > 编程语言 > 解决JDK8的ParallelStream遍历无序的问题
2021
11-19

解决JDK8的ParallelStream遍历无序的问题

JDK8的ParallelStream遍历无序

ParallelStream其实就是一个并行执行的流

它通过默认的ForkJoinPool，可能提高你的多线程任务的速度.

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

List    
       list = Arrays.asList(1, 2, 3, 4, 5);
list.parallelStream().forEach(out::println);

你得到的展示顺序不一定会是1、2、3、4、5，而可能是任意的顺序，就forEach()这个操作?斫玻?绻?叫写?硎保?Ｍ?詈笏承蚴前凑赵??tream的数据顺序，那可以调用forEachOrdered()。

List    
       list = Arrays.asList(1, 2, 3, 4, 5);
list.parallelStream().forEachOrdered(out::println);

parallelStream进行遍历的坑,以及如何进行避免异步操作中出现的问题

Java8 已经很久了，现在都已经Java12版本了.

我所在的上家公司，在写代码时候推荐使用lambad来进行操作遍历集合

也就是像下面一样

List<Integer> list = new ArrayList<>();
for (int j = 0; j < 1000; j++) {
list.add(j);
}
list.stream().forEach(value -> {
System.out.println(value);
});

这种效率其实和传统上的使用foreach以及for循环遍历效果差不多，因为点开forEach方法会发现内部其实使用的是下面的方法进行对集合遍历的

内部其实使用的还是for进行遍历，所以两者相比较其实没有什么效率的差异的，当然这也会由于每个公司编程习惯不一样，有的人更喜欢传统上的for进行遍历

因为上面的遍历方式不会对效率有什么提升, 所以由此还有一种方式就是

parallelStream()
List<Integer> list = new ArrayList<>();
for (int j = 0; j < 1000; j++) {
list.add(j);
}
list.parallelStream().forEach(value -> {
System.out.println(value);
});

上面的方法其实就是异步的，

这种遍历方式因为是异步遍历，会产生一种情况，就是遍历的顺序是无序的，当然也有相应的好处就是，遍历速度会快，当对生成结果不考虑排序问题而且数据量比较大的时候可以使用.

但是，有利自然有弊，因为异步的所以需要考虑线程的问题，就是生成的结果真的是你想要的么?

以下面的例子来运行一段代码：

public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for (int j = 0; j < 1000; j++) {
list.add(j);
}
System.out.println("最开始生成的集合长度:"+list.size());
//parallelStream遍历数据的时候会产生丢失的问题
for (int i = 0; i < 10 ; i++) {
  
List<Integer> parseList = new ArrayList<>();
list.parallelStream().forEach(integer -> {
parseList.add(integer);
});
System.out.println("每次遍历的集合长度:"+ parseList.size());
}
}

我首先创建了一个1000长度的集合，之后对这个集合使用多次遍历，然而呢，会发现，最后遍历的集合少数据，并且会在多次重复遍历的时候数组越界..

因为这种情况，之前工作使用parallelStream出现过2次问题， 我一直以为是使用parallelStream本身不够很安全导致的.实际上今天整理这篇博文突然才发现这个问题，就是遍历的结果转为的list是线程安全的么?

其实当正常进行遍历的时候， 可以对遍历出的结果核对，实际上每次遍历出的结果，仍然是与原来生成的结果一致的.

所以这边只能将锅甩在接收这些数据的list上面了

这个时候就需要对list进行包装

List<Integer> synchronizedList = Collections.synchronizedList(parseList);

这会在看下修改后的代码以及结果

public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for (int j = 0; j < 1000; j++) {
list.add(j);
}
System.out.println("最开始生成的集合长度:"+list.size());
//parallelStream遍历数据的时候会产生丢失的问题
for (int i = 0; i < 10 ; i++) {
  
List<Integer> parseList = new ArrayList<>();
List<Integer> synchronizedList = Collections.synchronizedList(parseList);
list.parallelStream().forEach(integer -> {
synchronizedList.add(integer);
});
System.out.println("每次遍历的集合长度:"+ synchronizedList.size());
}
}

这样每次遍历的结果也都是一样的，而且速度也会由于异步的会比之前效率提升好多

同样的如何创建线程安全的set，map也就可以进行相应的包装，这样就避免了使用会出新一些明明感觉对，确和自己想要的结果不一致的bug

同理使用parallelStream用StringBuffer 而不适用StringBuilder，因为前者是线程安全的

以上为个人经验，希望能给大家一个参考，也希望大家多多支持自学编程网。

编程技巧