Java中的parallelStream

一、概述

Java 中的 parallelStream 的底层实现为 ForkJoinPool 。
线程池是所有并行流共享的。
线程池的线程数量和CPU核数一致。
需要等待任务全部执行完毕,主线程(调用线程)才继续往下执行。

注意:因为线程池是全局共享的,所以我们尽量不要在 parallelStream 中执行阻塞任务,否则会影响到整个系统中其他的 parallelStream 任务执行的。

二、案例

下面的案例中使用了2个新线程,在其中分别执行 parallelStream 。
线程A启动后,我们暂停2秒,目的是为了让线程A中的任务占满 ForkJoinPool 中的线程,并且每个任务执行后,要暂停10秒,目的是为了方便我们观察 ForkJoinPool 中总共有多少个线程。

    public static void main(String[] args) {
        try {
            // 构建list数据
            List list = new ArrayList<>(20);
            for (int i = 0; i < 20; i++) {
                list.add(i);
            }

            // 启动第一个线程,在里面执行
            Thread t_A = new Thread(() -> {
                list.parallelStream().forEach((i) -> {
                    System.out.println(i + "=====A=====" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            });
            t_A.start();

            // 暂停2秒
            Thread.sleep(2000);

            //执行第二个线程
            Thread t_B = new Thread(() -> {
                list.parallelStream().forEach((i) -> {
                    System.out.println(i + "=====B=====" + Thread.currentThread().getName());
                });
            });
            t_B.start();

            t_A.join();
            t_B.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

执行结果如下:
注意查看,首先线程A中的任务执行了12条(包括调用线程自身),我使用的电脑CPU为12核心。
2秒钟后,线程B开始执行,此时线程A中的12个线程还处于阻塞状态,线程B中的任务,全部由调用线程执行。

12=====A=====Thread-0
6=====A=====ForkJoinPool.commonPool-worker-9
7=====A=====ForkJoinPool.commonPool-worker-6
2=====A=====ForkJoinPool.commonPool-worker-2
8=====A=====ForkJoinPool.commonPool-worker-11
4=====A=====ForkJoinPool.commonPool-worker-4
5=====A=====ForkJoinPool.commonPool-worker-15
1=====A=====ForkJoinPool.commonPool-worker-13
3=====A=====ForkJoinPool.commonPool-worker-8
9=====A=====ForkJoinPool.commonPool-worker-1
0=====A=====ForkJoinPool.commonPool-worker-10
17=====A=====ForkJoinPool.commonPool-worker-3
12=====B=====Thread-1
14=====B=====Thread-1
13=====B=====Thread-1
11=====B=====Thread-1
10=====B=====Thread-1
17=====B=====Thread-1
19=====B=====Thread-1
18=====B=====Thread-1
16=====B=====Thread-1
15=====B=====Thread-1
6=====B=====Thread-1
5=====B=====Thread-1
8=====B=====Thread-1
9=====B=====Thread-1
7=====B=====Thread-1
2=====B=====Thread-1
4=====B=====Thread-1
3=====B=====Thread-1
1=====B=====Thread-1
0=====B=====Thread-1
13=====A=====ForkJoinPool.commonPool-worker-11
18=====A=====ForkJoinPool.commonPool-worker-3
15=====A=====ForkJoinPool.commonPool-worker-9
10=====A=====ForkJoinPool.commonPool-worker-4
19=====A=====ForkJoinPool.commonPool-worker-10
16=====A=====ForkJoinPool.commonPool-worker-1
11=====A=====ForkJoinPool.commonPool-worker-13
14=====A=====ForkJoinPool.commonPool-worker-8

  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 的 Stream 是一种用于处理集合数据的抽象概念。它提供了一种流式处理数据的方式,可以进行各种操作,如过滤、映射、排序等。Stream API 提供了两种类型的流:Stream 和 ParallelStream。 Stream 是顺序流,它在单个线程上按顺序处理元素。而 ParallelStream 是并行流,它可以在多个线程上同时处理元素,从而加速处理过程。 使用 parallelStream 可以让 Stream 的操作并行执行,从而提高处理大量数据时的效率。在一些需要处理大型数据集的场景,使用 parallelStream 可以充分利用多核处理器的优势,并发地执行操作。 以下是一个简单的示例,展示了如何使用 parallelStream: ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // 使用 parallelStream 并行计算元素的平方 List<Integer> squares = numbers.parallelStream() .map(n -> n * n) .collect(Collectors.toList()); ``` 上述代码,我们创建了一个包含整数的列表 numbers。然后使用 parallelStream 方法将列表转换为并行流,并使用 map 方法计算每个元素的平方。最后,使用 collect 方法将结果收集到一个新的列表 squares 。 注意,虽然使用 parallelStream 可以加速处理过程,但并不是所有情况都适合并行化。在某些情况下,并行化可能会带来额外的开销或导致错误的结果。因此,在使用 parallelStream 时,需要仔细考虑使用场景,并评估是否适合并行化处理。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值