Java之parallelStream和stream

1、parallelStream是线程不安全的多线程并发操作

可以通过代码验证如下

googel的guava框架

       <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>

package com.example.demo.util;


import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import java.util.List;
import java.util.Map;

public class StreamTest {

    public static void main(String[] args) {

        //线程安全的map
        Map<String, String> one2 = Maps.newConcurrentMap();
        Map<String, String> two2 = Maps.newConcurrentMap();
        for (int i = 0; i < 1000; i++) {
            one2.put(i + "", i + "");
        }
        System.out.println("第一个集合的元素数:" + one2.size());
        // 多线程并发操作 线程安全map
        one2.entrySet().parallelStream().forEach(j->{
            two2.put(j.getKey(),j.getValue());
        });
        System.out.println("第二个集合的元素数:" + two2.size());//

        //线程不安全的map
        Map<String, String> one = Maps.newHashMap();
        Map<String, String> two = Maps.newHashMap();
        for (int i = 0; i < 1000; i++) {
            one.put(i + "", i + "");
        }
        System.out.println("第一个集合的元素数:" + one.size());
        // 多线程并发操作 线程不安全map
        one.entrySet().parallelStream().forEach(j->{
            two.put(j.getKey(),j.getValue());
        });
        System.out.println("第二个集合的元素数:" + two.size());//

        //线程不安全的map
        Map<String, String> one1 = Maps.newHashMap();
        Map<String, String> two1 = Maps.newHashMap();
        for (int i = 0; i < 1000; i++) {
            one1.put(i + "", i + "");
        }
        System.out.println("第一个集合的元素数:" + one1.size());
        // 单线程安全操作
        one1.entrySet().stream().forEach(j->{
            two1.put(j.getKey(),j.getValue());
        });
        System.out.println("第二个集合的元素数:" + two1.size());//

        //parallelStream 对线程不安全的集合操作
        parallelStreamNotSafe();
//
//        //parallelStream 对线程安全的集合操作
        parallelStreamSafe();
//
//        // stream对线程不安全的集合操作
        streamSafe();
    }

    public static void parallelStreamNotSafe() {
        //创建线程不安全的集合
        List<Integer> one = Lists.newArrayList();
        for (int i = 0; i < 1000; i++) {
            //插入100个数据
            one.add(i);
        }
        System.out.println("第一个集合的元素数:" + one.size());
        //线程不安全的集合
        List<Integer> two = Lists.newArrayList();
        //多线程并发
        one.parallelStream().forEach(e -> {
            //添加list的方法
            two.add(e);
            try {
                //休眠1ms，假装执行某些任务
                Thread.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        });
        //第二个集合的元素数会小于1000
        System.out.println("第二个集合的元素数:" + two.size());//
    }

    public static void parallelStreamSafe() {
        //创建线程安全的集合
        List<Integer> one = Lists.newCopyOnWriteArrayList();
        for (int i = 0; i < 1000; i++) {
            //插入100个数据
            one.add(i);
        }
        System.out.println("第一个集合的元素数:" + one.size());
        //线程安全的集合
        List<Integer> two = Lists.newCopyOnWriteArrayList();
        //多线程并发
        one.parallelStream().forEach(e -> {
            //添加list的方法
            two.add(e);
            try {
                //休眠1ms，假装执行某些任务
                Thread.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        });
        //第二个集合的元素数等于 1000
        System.out.println("第二个集合的元素数:" + two.size());
    }


    public static void streamSafe() {
        //创建线程不安全的集合
        List<Integer> one = Lists.newArrayList();
        for (int i = 0; i < 1000; i++) {
            //插入100个数据
            one.add(i);
        }
        System.out.println("第一个集合的元素数:" + one.size());
        //线程不安全的集合
        List<Integer> two = Lists.newArrayList();
        //单线程
        one.stream().forEach(e -> {
            //添加list的方法
            two.add(e);
            try {
                //休眠1ms，假装执行某些任务
                Thread.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        });
        //第二个集合的元素数等于 1000
        System.out.println("第二个集合的元素数:" + two.size());
    }
}

guava创建线程不安全的集合代码如下

 Map<String, String> one = Maps.newHashMap();
 List<Integer> one = Lists.newArrayList();

guava创建线程安全的集合代码如下

 List<Integer> one = Lists.newCopyOnWriteArrayList();
 Map<String, String> one2 = Maps.newConcurrentMap();

线程安全操作

        List<User> users = Lists.newArrayList();
        for (int i = 0; i < 1000; i++) {
            User user = User.builder().id(i)
                    .deptId(1).build();
            users.add(user);
        }
        //线程安全操作
        List<Integer> userId = users.parallelStream().map(i->i.getId()).collect(Collectors.toList());
        Map<Integer,User> map = users.parallelStream().collect(Collectors.toMap(i->i.getId(),i->i));
        Integer collect = users.parallelStream().collect(Collectors.summingInt(User::getDeptId));
        System.out.println(userId.size());
        System.out.println(map.size());
        System.out.println(collect);

stream的groupby操作

      List<User> users = Lists.newArrayList();
        for (int i = 0; i < 100; i++) {
            User user = User.builder()
                    .deptId(i)
                    .id(i)
                    .name("xxx" + i).build();
            if (i % 3 == 0) {
                user.setType("t1");
            } else if (i % 3 == 1) {
                user.setType("t2");
            } else {
                user.setType("t3");
            }
            users.add(user);
        }

        Map<String, Long> typeMap = users.parallelStream().collect(Collectors.groupingBy(User::getType, Collectors.counting()));
        System.out.println(typeMap.size());

Map<Long, List<PatrolPoint>> groupProjectMap = patrolPoints.parallelStream()
        .collect(Collectors.groupingBy(u -> u.getDutyId()));