Java：jdk8-并行流线程安全问题解决方案

        jdk8 Stream API的出现大大简化了我们对于集合元素的处理代码，对于串行流来说，无需考虑线程安全问题；但是，对于并行流来说，由于它是以多线程的方式并行处理同一个集合中的数据元素的，因此，存在着线程安全问题。

         例如：使用并行流向一个集合中存入数据，对于这种操作，由于这个集合对象是被作为共享资源使用的，如果不加注意，就会存在线程安全问题。如下所示，可能会直接抛出下标越界的异常，

  //methods
    public static void main(String[] args) {
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < 10000000; i++) {
            integers.add(i);
        }
        System.out.println(integers.size());

        //通过并行流将List中的数据转存到另一个List集合中
        List<Integer> another = new ArrayList<>();
        integers.parallelStream().forEach(another::add);
        System.out.println(another.size());
    }

 

         相应的，几种解决方案如下，

目录

方案1：同步锁

方案2：Collections工具类

方案3：同步容器

方案4：并发容器

---

方案1：同步锁

            示例代码如下，

 //5-同步锁+并行流
    private static void test5(){
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < 10000000; i++) {
            integers.add(i);
        }
        System.out.println(integers.size());

        //同步锁+并行流
        List<Integer> list = new ArrayList<>();
        Object o = new Object();//同步锁对象
        integers.parallelStream().forEach(e->{
            synchronized (o){
                list.add(e);
            }
        });
        System.out.println(list.size());
    }

 

方案2：Collections工具类

        示例代码如下，

//3-将非线程安全的集合，使用Collections工具类中的方法,转换为线程安全的同步容器+并行流
    private static void test3(){
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < 10000000; i++) {
            integers.add(i);
        }
        System.out.println(integers.size());

        //通过并行流将List中的数据转存到另一个线程安全的Vector集合中
        List<Integer> synchronizedList = Collections.synchronizedList( new ArrayList<>());
        integers.parallelStream().forEach(synchronizedList::add);
        System.out.println(synchronizedList.size());
    }

 

方案3：同步容器

        示例代码如下，

 //2-使用线程安全的容器Vector+并行流
    private static void test2(){
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < 10000000; i++) {
            integers.add(i);
        }
        System.out.println(integers.size());

        //通过并行流将List中的数据转存到另一个线程安全的Vector集合中
        List<Integer> vector = new Vector<>();
        integers.parallelStream().forEach(vector::add);
        System.out.println(vector.size());
    }

方案4：并发容器

             示例代码如下，

//4-使用并发容器CopyOnWriteArrayList+并行流
    private static void test4(){
        List<Integer> integers = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            integers.add(i);
        }
        System.out.println(integers.size());

        //使用并发容器-CopyOnWriteArrayList+并行流
        CopyOnWriteArrayList<Integer> arrayList = new CopyOnWriteArrayList<>();
        integers.parallelStream().forEach(arrayList::add);
        System.out.println(arrayList.size());
    }