个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
26
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章解决JDK8的ParallelStream遍历无序的问题由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
它通过默认的ForkJoinPool，可能提高你的多线程任务的速度. 。
Stream具有平行处理能力，处理的过程会分而治之，也就是将一个大任务切分成多个小任务，这表示每个任务都是一个操作，因此像以下的程式片段:
|
1
2
3
|
List
list = Arrays.asList(
1
,
2
,
3
,
4
,
5
);
list.parallelStream().forEach(out::println);
|
你得到的展示顺序不一定会是1、2、3、4、5，而可能是任意的顺序，就forEach()这个操作來讲，如果平行处理时，希望最后顺序是按照原来Stream的数据顺序，那可以调用forEachOrdered().
|
1
2
3
|
List
list = Arrays.asList(
1
,
2
,
3
,
4
,
5
);
list.parallelStream().forEachOrdered(out::println);
|
Java8 已经很久了，现在都已经Java12版本了. 。
我所在的上家公司，在写代码时候推荐使用lambad来进行操作遍历集合 。
也就是像下面一样 。
|
1
2
3
4
5
6
7
|
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进行遍历 。
因为上面的遍历方式不会对效率有什么提升, 所以由此还有一种方式就是 。
|
1
|
parallelStream()
|
|
1
2
3
4
5
6
7
|
List<Integer> list =
new
ArrayList<>();
for
(
int
j =
0
; j <
1000
; j++) {
list.add(j);
}
list.parallelStream().forEach(value -> {
System.out.println(value);
});
|
上面的方法其实就是异步的， 。
这种遍历方式因为是异步遍历，会产生一种情况，就是遍历的顺序是无序的，当然也有相应的好处就是，遍历速度会快，当对生成结果不考虑排序问题而且数据量比较大的时候可以使用. 。
但是，有利自然有弊，因为异步的所以需要考虑线程的问题，就是生成的结果真的是你想要的么？
以下面的例子来运行一段代码:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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进行包装 。
|
1
|
List<Integer> synchronizedList = Collections.synchronizedList(parseList);
|
这会在看下修改后的代码以及结果 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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，因为前者是线程安全的 。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.
原文链接：https://blog.csdn.net/u011051912/article/details/77051335 。
最后此篇关于解决JDK8的ParallelStream遍历无序的问题的文章就讲到这里了,如果你想了解更多关于解决JDK8的ParallelStream遍历无序的问题的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
26
4
0
这个问题已经有答案了: How do I write a correct micro-benchmark in Java? (11 个回答) 已关闭 5 年前。 我正在对 Java 聚合操作进行一些性
我发现我对并行流提供的一致性保证略有挣扎: 1. myList.parallelStream().map(mymapper).forEach(myFn) 2. // Is myFn guarantee
我有一个方法可以并行计算列表中数字的平方并将它们相加: public static double sumSquared(List values) { return values
这个问题已经有答案了: How do Java 8 parallel streams behave on a thrown exception? (1 个回答) 已关闭 4 年前。 我正在研究java
通常当使用 Java 8 的 parallelStream() 时，结果是通过默认的、通用的 fork-join 池(即 ForkJoinPool.commonPool())执行。 这显然是不可取的，
Java 8 parallelStream 似乎使用了比系统属性 java.util.concurrent.ForkJoinPool.common.parallelism 指定的线程更多的线程。这些单
我有以下代码，有时它的行为不确定。例如，我在那里传递了 3 个事件，而输出只有两个!你能解释一下这种行为的原因吗？ public List getEventResponse(final List ev
Java8并行流（parallelStream）注意点 在最初使用并行流的时候，查询列表会偶尔性报空指针异常，这令我非常纳闷 代码是这样的： ?
使用示例可能更容易解释我想要做的事情。假设我必须遵循两个数组: int firstArray[] = {1, 2, 3, 4, 5}; int secArray[] = {1, 2, 3, 4, 5}
我正在尝试使用 chronicleMap.parallelStream: myChronicleMap.entrySet().parallelStream().forEach((entry) -> {
我正在使用parallelStream并行上传一些文件，有些是大文件，有些是小文件。我注意到并非所有 worker 都被使用。 一开始一切都运行良好，所有线程都被使用(我将并行度选项设置为 16)。然
这个问题在这里已经有了答案: How can I turn a List of Lists into a List in Java 8? (12 个答案) 关闭 8 年前。 我想将并行流中的列表结果
我有以下代码 public void addNames(){ List names = new ArrayList names.parallelStream().foreach(name-
如果输入大小太小，库 automatically serializes the execution of the maps in the stream ，但这种自动化没有也不能考虑 map 操作的繁重
我创建了一个并行度为 25 的自定义 ForkJoinPool。 customForkJoinPool = new ForkJoinPool(25); 我有一个包含 700 个文件名的列表，我使用这样
我在 Internet 上看到了很多示例，为了使用流 API 来执行并行操作，只需像这样调用 .parallelStream() 方法: mySet .parallelStream()
考虑这个(完全人为的)Java 代码: final List s = Arrays.asList(1, 2, 3); final int[] a = new int[1]; a[0] = 100; s
谁能告诉我为什么会这样，这是预期的行为还是错误 List a = Arrays.asList(1,1,3,3); a.parallelStream().filter(Objects::nonNull)
方法一 通常，非常快，并且效果很好。 public static int loops = 500; private static ExecutorService customPool = Execut
默认情况下，parallelStream 内的 commonPool 大小应为 cpu_cores - 1。 但是，在我的应用程序中，它始终大于硬件 cpu_cores。 VisualVM 截图: 很
我是一名优秀的程序员,十分优秀！