Java 集合类的线程安全问题及解决方法

一、List

1.1 模拟多线程环境

       多线程环境下，会抛出 java.util.ConcurrentModificationException 异常

public static void listNotSafe() {
    List<String> list = new CopyOnWriteArrayList<>();

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

1.2 异常原因

   多线程环境下，并发争抢修改导致出现该异常。

1.3 解决办法

// 1. 使用线程安全类 Vector
new Vector();

// 2. 使用 Collections 工具类封装 ArrayList
Collections.synchronizedList(new ArrayList<>());

// 3. 使用 java.util.concurrent.CopyOnWriteArrayList;
new CopyOnWriteArrayList<>();

1.4 写时复制思想

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

// CopyOnWriteArrayList.java
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();
    }
}

二、Set

2.1 线程安全问题

       与 List 接口的测试方法相似，同样会抛出 java.util.ConcurrentModificationException 异常。

2.2 解决办法

// 1. 使用 Collections 工具类封装
Collections.synchronizedSet(new HashSet<>());

// 2. 使用 java.util.concurrent.CopyOnWriteArraySet;
new CopyOnWriteArraySet<>();

2.3 CopyOnWriteArraySet

       final ReentrantLock lock = this.lock; 为什么声明为 final？参考可以看看这个 https://blog.csdn.net/zqz_zqz/article/details/79438502

// 底层实际上是一个 CopyOnWriteArrayList
public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {
    private static final long serialVersionUID = 5457747651344034263L;

    private final CopyOnWriteArrayList<E> al;

    // ...
}

// 添加元素，相当于调用 CopyOnWriteArrayList 的 addIfAbsent() 方法
public class CopyOnWriteArraySet<E> {
    public boolean add(E e) {
        return al.addIfAbsent(e);
    }
}

/**
 * CopyOnWriteArrayList 的 addIfAbsent() 方法
 * Set 集合中的元素不可重复，如果原集合中有要添加的元素，则直接返回 false
 * 否则，将该元素加入集合中
 */
public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
        addIfAbsent(e, snapshot);
}

/**
 * 重载的 addIfAbsent() 方法，用于真正添加元素加锁后，再次获取集合，与刚才拿到的集合比较，
 * 两次拿到的不一样，说明集合被其他线程修改过了，重新比较最新集合中有没有该元素，如果比较
 * 后，没有返回 false，说明没有该元素，执行下面的添加方法。
 */
private boolean addIfAbsent(E e, Object[] snapshot) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) {
            // Optimize for lost race to another addXXX operation
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++)
                if (current[i] != snapshot[i] && eq(e, current[i]))
                    return false;
            if (indexOf(e, current, common, len) >= 0)
                return false;
        }
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

三、Map

3.1 线程安全问题

       和上面一样，多线程环境下，会抛出 java.util.ConcurrentModificationException 异常。

3.2 解决办法

// 使用 Collections 工具类
Collections.synchronizedMap(new HashMap<>());

// 使用 ConcurrentHashMap
new ConcurrentHashMap<>();

3.3 HashMap、Hashtable 和 ConcurrentHashMap 的区别

继承不同：HashMap继承AbstractMap, Hashtable继承Dictonary，ConcurrentHashMap除了继承AbstractMap还实现了ConcurrentMap接口

线程是否安全：HashMap非线程安全，ConcurrentHashMap 和 Hashtable 线程安全，但是他们的实现机制不同，Hashtabl e使用synchronized实现同步方法，而ConcurrentHashMap降低锁的粒度，拥有更好的并发性能。

Key-Value值：ConcurrentHashMap和Hashtable都不允许value和key为null，但是HashMap允许唯一的key为null，和任意个value为null

哈希算法不同：HashMap 和 Jdk 8 中的 ConcurrentHashMap 的算法一致都是使用 key 的 hashcode 值进行高16位和低16位异或再取模长度，而Hashtable是直接对 key 的hashcode值进行取模操作 。

扩容机制不同：ConcurrentHashMap和HashMap的扩容机制和初始容量一致，扩容为原有数组长度的两倍，初始容量为16，但是hashtable中的初始容量为11，容量为原有长度的两倍+1。

失败机制：ConcurrentHashMap支持安全失败，HashMap和hashtable支持的快速失败

查询方法：HashMap没有contains方法，但是拥有containsKey和containsValue方法，Hashtable和ConcurrentHashMap还支持contains方法

迭代方式：ConcurrentHashMap和Hashtable还支持Enumeration迭代方式