Java 8 parallel parallelStream 性能测试

本机

Runtime.getRuntime().availableProcessors()返回的是可用的计算资源，而不是CPU物理核心数，对于支持超线程的CPU来说，单个物理处理器相当于拥有两个逻辑处理器，能够同时执行两个线程。

获取的是cpu核心线程数也就是计算资源。

cpu密集型计算推荐设置线程池核心线程数为N，也就是和cpu的线程数相同，可以尽可能低避免线程间上下文切换。

io密集型计算推荐设置线程池核心线程数为2N，但是这个数一般根据业务压测出来的，如果不涉及业务就使用推荐。

Runtime.getRuntime().availableProcessors()方法询问jvm，jvm去问操作系统，操作系统去问硬件。。。。。。。

package com.zemcho.echo.csdn;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

/**
 * @author linliangxuan
 * @date 2021/8/31 16:59
 */
@Slf4j
public class ParallelImprovedResourceTest {

    public static void main(String[] args) throws IOException, InterruptedException {


        log.info("本机 Runtime.getRuntime().availableProcessors ===  {}", Runtime.getRuntime().availableProcessors());

        List<Integer> datas = getIntegers(200);

        new Thread(() -> {

            parallel(datas);

        }).start();


        new Thread(() -> {

            nonParallel(datas);

        }).start();

        new Thread(() -> {

            parallelStream(datas);

        }).start();


        Thread.sleep(1000);

    }


    private static void nonParallel(List<Integer> datas) {

        final long currentTimeMillis = System.currentTimeMillis();

        log.info("nonParallel  非并发迭代-------------------- start");

        datas.stream().forEach(i -> sleep());

        log.info("nonParallel  非并发迭代-------------------- end  花费时长 = {}", System.currentTimeMillis() - currentTimeMillis);

    }

    private static List<Integer> getIntegers(int size) {
        return new Random().ints(size, 0, 10000000).boxed().collect(Collectors.toList());
    }

    private static void sleep() {
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void parallel(List<Integer> datas) {

        final long currentTimeMillis = System.currentTimeMillis();

        log.info("parallel 并发迭代  start");

        datas.stream().parallel().forEach(i -> sleep());

        log.info("parallel 并发迭代-------------------- end  花费时长 = {}", System.currentTimeMillis() - currentTimeMillis);

    }

    private static void parallelStream(List<Integer> datas) {

        final long currentTimeMillis = System.currentTimeMillis();
        log.info("parallelStream 并发迭代  start");

        datas.parallelStream().forEach(i -> sleep());

        log.info("parallelStream 并发迭代-------------------- end  花费时长 = {}", System.currentTimeMillis() - currentTimeMillis);

    }
}

另一台机器，4 核心的机器

    // TODO localhost:1881/demo/parallelStream
    @GetMapping("/parallelStream")
    public DataResponse parallelStream ( ){

        log.info("本机 Runtime.getRuntime().availableProcessors ===  {}", Runtime.getRuntime().availableProcessors());

        final long currentTimeMillis = System.currentTimeMillis();

        log.info("parallelStream  并发迭代-------------------- start");
        final List<Integer> integers = getIntegers(100);

        integers.parallelStream().forEach(i ->
                {
                    try{
                        crmGateway.queryCustomerById(""+1)  ;
                    }catch (Exception exception){
                    }
                }
        );

        log.info("parallelStream  并发迭代-------------------- end  花费时长 = {}", System.currentTimeMillis() - currentTimeMillis);

        return DataResponse.of(String.valueOf(System.currentTimeMillis() - currentTimeMillis));
    }


    // TODO localhost:1881/demo/nonParallel
    @GetMapping("/nonParallel")
    public DataResponse nonParallel ( ){

        final long currentTimeMillis = System.currentTimeMillis();

        log.info("nonParallel  非并发迭代-------------------- start");
        final List<Integer> integers = getIntegers(100);

        integers.stream().forEach(i ->
                {
                    try{
                        crmGateway.queryCustomerById(""+1)  ;
                    }catch (Exception exception){
                    }
                }
        );

        log.info("nonParallel  非并发迭代-------------------- end  花费时长 = {}", System.currentTimeMillis() - currentTimeMillis);

        return DataResponse.of(String.valueOf(System.currentTimeMillis() - currentTimeMillis));
    }

    private  List<Integer> getIntegers(int size) {
        return new Random().ints(size, 0, 10000000).boxed().collect(Collectors.toList());
    }

非并发的话， 1500 ms ， 并发 基本稳定再 360 ms

为什么呢？？？？