批量数据处理之测试过程记录

• 100次 方法阻塞10ms 单次数据量20

处理方式	处理时间（ms）	线程安全	结论
stream	23074	安全	安全但效率低，不推荐
parallelStream	4584	不安全	谨慎使用
synchronizedList	4628	安全	推荐使用 效率非最优
copyOnWriteArrayList	4533	安全	安全且耗时最低 但底层添加存在空间换时间思路 超大数据量 谨慎使用
parallelStream+collect	4554	安全	推荐使用 异步处理数据 同步收集结果
stream+collect	22624	安全	安全但效率低，不推荐

• 1000次 方法阻塞1ms 单次数据量20

处理方式	处理时间（ms）	线程安全	结论
stream	25504	安全	安全但效率低，不推荐
parallelStream	4996	不安全	谨慎使用
synchronizedList	5227	安全	推荐使用 底层加锁保证数据安全 效率非最优
copyOnWriteArrayList	5184	安全	安全且耗时最低 但底层添加存在空间换时间思路 超大数据量 谨慎使用
parallelStream+collect	5194	安全	推荐使用 异步处理数据 同步收集结果
stream+collect	25755	安全	安全但效率低，不推荐

• 100次 方法阻塞3ms 单次数据量100

处理方式	处理时间（ms）	线程安全	结论
stream	35697	安全	安全但效率低，不推荐
parallelStream	5809	不安全	谨慎使用
synchronizedList	5836	安全	推荐使用 底层加锁保证数据安全 效率非最优
copyOnWriteArrayList	5749	安全	安全且耗时最低 但底层添加存在空间换时间思路 超大数据量 谨慎使用
parallelStream+collect	5811	安全	推荐使用 异步处理数据 同步收集结果
stream+collect	36450	安全	安全但效率低，不推荐

• 100次 方法阻塞3ms 单次数据量1000

处理方式	处理时间（ms）	线程安全	结论
stream	不测试了、太慢	安全	安全但效率低，不推荐
parallelStream	50632	不安全	谨慎使用
synchronizedList	48468	安全	推荐使用 底层加锁保证数据安全 效率非最优
copyOnWriteArrayList	47498	安全	安全且耗时最低、但底层添加存在空间换时间思路、看监控有明显GC行为、 超大数据量时谨慎使用
parallelStream+collect	46540	安全	推荐使用 异步处理数据 同步收集结果，同步收集结果时，内存使用有一定抖动
stream+collect	不测试了、太慢	安全	安全但效率低，不推荐

• parallelStream+collect

• copyOnWriteArrayList

• synchronizedList

• 测试代码

package com.example.demobootwangyan;
​
import com.example.demobootwangyan.controller.User;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
​
/
public class TestA {
​
​
    public static void main(String[] args) {
        stream(100, 1000);
//        parallelStream(100, 1000);
//        synchronizedList(100, 1000);
//        copyOnWriteArrayList(100, 1000);
//        parallelStreamCollect(100, 1000);
//        streamCollect(100, 1000);
    }
​
    public static User getUserById(int id) {
        User user = new User();
        try {
            user.setUserId(String.valueOf(id));
            user.setStatus("1");
            Thread.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return user;
    }
​
​
    public static void stream(int count, int setCount) {
        long start = System.currentTimeMillis();
        //初始化set集合
        Set<Integer> set = initSet(setCount);
        for (int i = 0; i < count; i++) {
            List<User> result = new ArrayList<>(set.size());
            set.stream().forEach(id -> {
                User user = getUserById(id);
                result.add(user);
            });
            if (result.size() != set.size()) {
                System.out.println("数据丢失");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("stream执行耗时:" + (end - start));
    }
​
    public static void parallelStream(int count, int setCount) {
        long start = System.currentTimeMillis();
        Set<Integer> set = initSet(setCount);
        for (int i = 0; i < count; i++) {
            List<User> result = new ArrayList<>(set.size());
            set.parallelStream().forEach(id -> {
                User user = getUserById(id);
                result.add(user);
            });
            if (result.size() != set.size()) {
                System.out.println("数据丢失");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("parallelStream执行耗时:" + (end - start));
    }
​
    public static void synchronizedList(int count, int setCount) {
        long start = System.currentTimeMillis();
        Set<Integer> set = initSet(setCount);
        for (int i = 0; i < count; i++) {
            List<User> result = Collections.synchronizedList(new ArrayList<>());
            set.parallelStream().forEach(id -> {
                User user = getUserById(id);
                result.add(user);
            });
            if (result.size() != set.size()) {
                System.out.println("数据丢失");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("synchronizedList执行耗时:" + (end - start));
    }
​
    public static void copyOnWriteArrayList(int count, int setCount) {
        long start = System.currentTimeMillis();
        Set<Integer> set = initSet(setCount);
        for (int i = 0; i < count; i++) {
            List<User> result = Lists.newCopyOnWriteArrayList();
            set.parallelStream().forEach(id -> {
                User user = getUserById(id);
                result.add(user);
            });
            if (result.size() != set.size()) {
                System.out.println("数据丢失");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("copyOnWriteArrayList执行耗时:" + (end - start));
    }
​
    public static void parallelStreamCollect(int count, int setCount) {
        long start = System.currentTimeMillis();
        Set<Integer> set = initSet(setCount);
        for (int i = 0; i < count; i++) {
            List<User> result = set.parallelStream().map(TestA::getUserById).collect(Collectors.toList());
            if (result.size() != set.size()) {
                System.out.println("数据丢失");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("parallelStreamCollect执行耗时:" + (end - start));
    }
​
    public static void streamCollect(int count, int setCount) {
        long start = System.currentTimeMillis();
        Set<Integer> set = initSet(setCount);
        for (int i = 0; i < count; i++) {
            List<User> result = set.stream().map(TestA::getUserById).collect(Collectors.toList());
            if (result.size() != set.size()) {
                System.out.println("数据丢失");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("streamCollect执行耗时:" + (end - start));
    }
​
​
    public static Set<Integer> initSet(int count) {
        Set<Integer> set = Sets.newHashSet();
        for (int i = 1; i <= count; i++) {
            set.add(i);
        }
        return set;
    }
​
​
}

\