JUC之集合安全问题

为什么不安全

以ArrayList为例

ArrayList单线程代码

List<String> list = new ArrayList<>();
for (int i = 1; i <= 3; i++) {
    list.add(UUID.randomUUID().toString().substring(0, 8));
    System.out.println(list);
}

每次运行完都是随机的3个uuid字符串，顺序打印，是符合我们预期的

[03615414]
[03615414, de65fd4c]
[03615414, de65fd4c, ce776a60]

ArrayList多线程代码

List<String> list = new ArrayList<>();
for (int i = 1; i <= 3; i++) {
    new Thread(() -> {
        list.add(UUID.randomUUID().toString().substring(0, 8));
        System.out.println(list);
    }, String.valueOf(i)).start();
}

问题1-每次结果都不一致

我们随便执行几次，发现和我们预期不一样了

[null, d9103741]
[null, d9103741, b40a700d]
[null, d9103741]

比如这个运行结果，第一个循环怎么回打印了3个元素，而且有null

[null, null, 784816ec]
[null, null, 784816ec]
[null, null, 784816ec]

[7688161d]
[7688161d, 3dafce5e]
[7688161d, 3dafce5e, e7444c92]

问题2- 线程多的情况下直接异常

java.util.ConcurrentModificationException

原因

多线程并发争抢同一个资源类且没加锁

解决方案

Vector

List<String> list = new Vector<>();

加了synchronized

    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

利用Collections工具类

List<String> list = Collections.synchronizedList(new ArrayList<>())

这个方法回根据你传入的List是否实现RandomAccess这个接口来返回的SynchronizedRandomAccessList还是SynchronizedList

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new SynchronizedRandomAccessList<>(list) :
            new SynchronizedList<>(list));
}

concurrent包

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;

List<String> list = new CopyOnWriteArrayList();

CopyOnWriteArrayList

写时复制急速

• CopyOnWrite容器即写时复制的容器。
• 往一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前容器Object[]进行Copy，复制出一个新的容器Object[]newElements，然后新的容器Object[] newElements里添加元素
• 添加完元素之后，再将原容器的引用指向新的容器 setArray(newElements);
• 这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素，但是add还是要加锁的，不能同时写
• 所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器

源码

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();

        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

CopyOnWriteSet

跟List类似，HashSet和TreeSet都不是线程安全的，与之对应的有CopyOnWriteSet这个线程安全类。这个类底层维护了一个CopyOnWriteArrayList数组。

private final CopyOnWriteArrayList<E> al;
public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList<E>();
}

ConcurrentHashMap

其他集合

除了ArrayList还有HashSet，HashMap同样如此

java.util.concurrent.ConcurrentHashMap;
java.util.concurrent.CopyOnWriteArrayList;
java.util.concurrent.CopyOnWriteArraySet;