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迭代方式