爲何 ConcurrentHashMap 的讀操做不須要加鎖？

做者：上帝愛吃蘋果
地址：www.cnblogs.com/keeya/p/9632958.html

咱們知道，ConcurrentHashmap(1.8)這個併發集合框架是線程安全的，當你看到源碼的get操做時，會發現get操做全程是沒有加任何鎖的，這也是這篇博文討論的問題——爲何它不須要加鎖呢？

ConcurrentHashMap的簡介

我想有基礎的同窗知道在jdk1.7中是採用Segment + HashEntry + ReentrantLock的方式進行實現的，而1.8中放棄了Segment臃腫的設計，取而代之的是採用Node + CAS + Synchronized來保證併發安全進行實現。

• JDK1.8的實現下降鎖的粒度，JDK1.7版本鎖的粒度是基於Segment的，包含多個HashEntry，而JDK1.8鎖的粒度就是HashEntry（首節點）
• JDK1.8版本的數據結構變得更加簡單，使得操做也更加清晰流暢，由於已經使用synchronized來進行同步，因此不須要分段鎖的概念，也就不須要Segment這種數據結構了，因爲粒度的下降，實現的複雜度也增長了
• JDK1.8使用紅黑樹來優化鏈表，基於長度很長的鏈表的遍歷是一個很漫長的過程，而紅黑樹的遍歷效率是很快的，代替必定閾值的鏈表，這樣造成一個最佳拍檔

get操做源碼

1. 首先計算hash值，定位到該table索引位置，若是是首節點符合就返回
2. 若是遇到擴容的時候，會調用標誌正在擴容節點ForwardingNode的find方法，查找該節點，匹配就返回
3. 以上都不符合的話，就往下遍歷節點，匹配就返回，不然最後就返回null

//會發現源碼中沒有一處加了鎖
public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode()); //計算hash
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {//讀取首節點的Node元素
        if ((eh = e.hash) == h) { //若是該節點就是首節點就返回
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //hash值爲負值表示正在擴容，這個時候查的是ForwardingNode的find方法來定位到nextTable來
        //eh=-1，說明該節點是一個ForwardingNode，正在遷移，此時調用ForwardingNode的find方法去nextTable裏找。
        //eh=-2，說明該節點是一個TreeBin，此時調用TreeBin的find方法遍歷紅黑樹，因爲紅黑樹有可能正在旋轉變色，因此find裏會有讀寫鎖。
        //eh>=0，說明該節點下掛的是一個鏈表，直接遍歷該鏈表便可。
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {//既不是首節點也不是ForwardingNode，那就往下遍歷
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

get沒有加鎖的話，ConcurrentHashMap是如何保證讀到的數據不是髒數據的呢?

volatile登場

對於可見性，Java提供了volatile關鍵字來保證可見性、有序性。但不保證原子性。

普通的共享變量不能保證可見性，由於普通共享變量被修改以後，何時被寫入主存是不肯定的，當其餘線程去讀取時，此時內存中可能仍是原來的舊值，所以沒法保證可見性。

• volatile關鍵字對於基本類型的修改能夠在隨後對多個線程的讀保持一致，可是對於引用類型如數組，實體bean，僅僅保證引用的可見性，但並不保證引用內容的可見性。。
• 禁止進行指令重排序。

背景：爲了提升處理速度，處理器不直接和內存進行通訊，而是先將系統內存的數據讀到內部緩存（L1，L2或其餘）後再進行操做，但操做完不知道什麼時候會寫到內存。

• 若是對聲明瞭volatile的變量進行寫操做，JVM就會向處理器發送一條指令，將這個變量所在緩存行的數據寫回到系統內存。可是，就算寫回到內存，若是其餘處理器緩存的值仍是舊的，再執行計算操做就會有問題。
• 在多處理器下，爲了保證各個處理器的緩存是一致的，就會實現緩存一致性協議，當某個CPU在寫數據時，若是發現操做的變量是共享變量，則會通知其餘CPU告知該變量的緩存行是無效的，所以其餘CPU在讀取該變量時，發現其無效會從新從主存中加載數據。

總結下來：

• 第一：使用volatile關鍵字會強制將修改的值當即寫入主存；
• 第二：使用volatile關鍵字的話，當線程2進行修改時，會致使線程1的工做內存中緩存變量的緩存行無效（反映到硬件層的話，就是CPU的L1或者L2緩存中對應的緩存行無效）；
• 第三：因爲線程1的工做內存中緩存變量的緩存行無效，因此線程1再次讀取變量的值時會去主存讀取。

是加在數組上的volatile嗎？

/**
 * The array of bins. Lazily initialized upon first insertion.
 * Size is always a power of two. Accessed directly by iterators.
 */
transient volatile Node<K,V>[] table;

咱們知道volatile能夠修飾數組的，只是意思和它表面上看起來的樣子不一樣。舉個栗子，volatile int array[10]是指array的地址是volatile的而不是數組元素的值是volatile的。

用volatile修飾的Node

get操做能夠無鎖是因爲Node的元素val和指針next是用volatile修飾的，在多線程環境下線程A修改結點的val或者新增節點的時候是對線程B可見的。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    //能夠看到這些都用了volatile修飾
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey()       { return key; }
    public final V getValue()     { return val; }
    public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
    public final String toString(){ return key + "=" + val; }
    public final V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    public final boolean equals(Object o) {
        Object k, v, u; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                (k == key || k.equals(key)) &&
                (v == (u = val) || v.equals(u)));
    }

    /**
     * Virtualized support for map.get(); overridden in subclasses.
     */
    Node<K,V> find(int h, Object k) {
        Node<K,V> e = this;
        if (k != null) {
            do {
                K ek;
                if (e.hash == h &&
                    ((ek = e.key) == k || (ek != null && k.equals(ek))))
                    return e;
            } while ((e = e.next) != null);
        }
        return null;
    }
}

既然volatile修飾數組對get操做沒有效果那加在數組上的volatile的目的是什麼呢？

其實就是爲了使得Node數組在擴容的時候對其餘線程具備可見性而加的volatile

總結

• 在1.8中ConcurrentHashMap的get操做全程不須要加鎖，這也是它比其餘併發集合好比hashtable、用Collections.synchronizedMap()包裝的hashmap;安全效率高的緣由之一。
• get操做全程不須要加鎖是由於Node的成員val是用volatile修飾的和數組用volatile修飾沒有關係。
• 數組用volatile修飾主要是保證在數組擴容的時候保證可見性。

另外，關注公衆號Java技術棧，在後臺回覆：面試，能夠獲取我整理的 Java 系列面試題和答案，很是齊全。
近期熱文推薦：

1.600+ 道 Java面試題及答案整理(2021最新版)

2.終於靠開源項目弄到 IntelliJ IDEA 激活碼了，真香！

3.阿里 Mock 工具正式開源，幹掉市面上全部 Mock 工具！

4.Spring Cloud 2020.0.0 正式發佈，全新顛覆性版本！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

以爲不錯，別忘了隨手點贊+轉發哦！