Java基础-并发编程-List与并发包List

Java工程师知识树 / Java基础

---

集合ArrayList操作并发冲突

ArrayList线程不安全实例

public static void main(String[] args) {
    testArrayListAdd();
}

private static void testArrayListAdd() {
    List arrayList = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            arrayList.add(RandomUtil.randomInt());
            System.out.println(arrayList.toString());
        }).start();
    }
}
打印结果：
Exception in thread "Thread-8" Exception in thread "Thread-2" java.util.ConcurrentModificationException
    ...

ArrayList线程不安全原因

导致产生ConcurrentModificationException异常原因：ArrayList里使用modCount++，++运算在多线程中是不安全的。
modCount主要是为了防止在迭代过程中某些原因改变了原集合，导致出现不可预料的情况，从而抛出并发修改异常，是ArrayList里的Fail-Fast机制。

//add方法modCount操作源码
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

ArrayList线程不安全解决方案

ArrayList线程不安全解决方案：

• new Vector<>()
• Collections.synchronizedList(new ArrayList<>())
• new CopyOnWriteArrayList<>()

package com.study.thread.conllection;

import cn.hutool.core.util.RandomUtil;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListTest {


    public static void main(String[] args) {
        testArrayListAdd();
//        testArrayListAdd2();
//        testCopyOnWriteArrayListAdd();
//        testVectorAdd();
    }

    private static void testArrayListAdd() {
        List arrayList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                arrayList.add(RandomUtil.randomInt());
                System.out.println(arrayList.toString());
            }).start();
        }
    }

    private static void testCopyOnWriteArrayListAdd() {
        CopyOnWriteArrayList copyOnwirteArrayList = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                copyOnwirteArrayList.add(RandomUtil.randomInt());
                System.out.println(copyOnwirteArrayList.toString());
            }).start();
        }
    }


    private static void testArrayListAdd2() {
        List arrayList = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                arrayList.add(RandomUtil.randomInt());
                System.out.println(arrayList.toString());
            }).start();
        }
    }

    private static void testVectorAdd() {
        List vector = new Vector<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                vector.add(RandomUtil.randomInt());
                System.out.println(vector.toString());
            }).start();
        }
    }
}

CopyOnWriteArrayList如何做到线程安全的

CopyOnWriteArrayList使用了一种叫 写时复制 的方法，当有新元素添加到CopyOnWriteArrayList时，先从原有的数组中拷贝一份出来，然后在新的数组做写操作，写完之后，再将原来的数组引用指向到新数组。

当有新元素加入的时候，如下图，创建新数组，并往新数组中加入一个新元素,这个时候，array这个引用仍然是指向原数组的。

当元素在新数组添加成功后，将array这个引用指向新数组。

CopyOnWriteArrayList的整个add操作都是在锁的保护下进行的。
这样做是为了避免在多线程并发add的时候，复制出多个副本出来,把数据搞乱了，导致最终的数组数据不是我们期望的。

CopyOnWriteArrayList的add操作的源代码如下：

public boolean add(E e) {
    //1、先加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        //2、拷贝数组
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        //3、将元素加入到新数组中
        newElements[len] = e;
        //4、将array引用指向到新数组
        setArray(newElements);
        return true;
    } finally {
       //5、解锁
        lock.unlock();
    }
}

由于所有的写操作都是在新数组进行的，这个时候如果有线程并发的写，则通过锁来控制，如果有线程并发的读，则分几种情况：
1、如果写操作未完成，那么直接读取原数组的数据；
2、如果写操作完成，但是引用还未指向新数组，那么也是读取原数组数据；
3、如果写操作完成，并且引用已经指向了新的数组，那么直接从新数组中读取数据。

可见，CopyOnWriteArrayList的读操作是可以不用加锁的。

CopyOnWriteArrayList的使用场景

通过上面的分析，CopyOnWriteArrayList 有几个缺点：
1、由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致young gc或者full gc

2、不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求；

CopyOnWriteArrayList 合适读多写少的场景，不过这类慎用，在使用时需确认操作的元素大小极限值。
CopyOnWriteArrayList 中的数据如果很多的话，每次add/set都要重新复制数组，代价就会很高。在高性能的互联网应用中，这种操作极易引起故障。

CopyOnWriteArrayList 和 Vector 的区别

• Vector是【绝对】线程安全的，CopyOnWriteArrayList只能保证读线程会读到【已完成】的写结果，但无法像Vector一样实现读操作的【等待写操作完成后再读最新值】的能力
• CopyOnWriteArrayList读性能远高于Vector，并发线程越多优势越明显
• CopyOnWriteArrayList占用更多的内存空间
• Vector 不能避免 ConcurrentModificationException 问题，而 CopyOnWriteArrayList 不存在这个问题。