Java并行流注意事项

https://hacpai.com/article/1578380907025

 

实体类：

@ToString
@Data
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;

    private BigDecimal age;

    private User user;

}

下面是性能对比的代码：

public static void main(String[] args) {
        List<User> users = new ArrayList<>();

        User user = new User();
        user.setAge(new BigDecimal(1.5));
        users.add(user);

        user = new User();
        user.setAge(new BigDecimal(0.3));
        users.add(user);

        user = new User();
        user.setAge(new BigDecimal(0.7));
        users.add(user);

        user = new User();
        user.setAge(new BigDecimal(3.5));
        users.add(user);

        for(int i = 0 ; i < 10000000; i++) {
            user = new User();
            user.setAge(new BigDecimal(3.5));
            users.add(user);
        }



        System.out.println(users.size());
        List<User> synchronizedList = Collections.synchronizedList(users);

        //开始时间
        long startTime = System.currentTimeMillis();
        //Java Lambda 表达式 forEach方式
        users.stream().forEach(forEachUser-> forEachUser.getAge());

        //结束时间
        long endTime = System.currentTimeMillis();

        System.out.println("Lambda 表达式forEach方式遍历的时间为："+(endTime - startTime));



        //迭代器方式遍历
        long startTime1 = System.currentTimeMillis();

        Iterator<User> iterator = users.iterator();
        while (iterator.hasNext()) {
            User next = iterator.next();
            next.getAge();
        }
        long endTime1 = System.currentTimeMillis();

        System.out.println("迭代器方式遍历的时间为："+(endTime1 - startTime1));


        //普通for循环
        long startTime2 = System.currentTimeMillis();

        for(int i = 0; i < users.size(); i++) {
            users.get(i).getAge();
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("普通for循环遍历的时间为："+(endTime2 - startTime2));

        //并行流方式
        long startTime4 = System.currentTimeMillis();

        users.parallelStream().forEach(forEachUser -> {
            forEachUser.getAge();
        });

        long endTime4 = System.currentTimeMillis();
        System.out.println("并行流的forEach的遍历时间为"+(endTime4 - startTime4));
    }

对比结果：

10000004
Lambda 表达式forEach方式遍历的时间为：118
迭代器方式遍历的时间为：83
普通for循环遍历的时间为：80
并行流的forEach的遍历时间为52

 

其实这样结果我很意外，因为在昨天并行流的对比结果相对差多了，也就比Lambda的foreach快点,之后我把并行流的顺序放在第一位结果如下：

并行流的forEach的遍历时间为114
Lambda 表达式forEach方式遍历的时间为：89
迭代器方式遍历的时间为：93
普通for循环遍历的时间为：89

突然发现并行流的速度差了很多，原因未知。