探索 ConcurrentHashMap 高併發性的實現機制

 static final class HashEntry<K,V> { 
        final K key;                       // 宣告 key 為 final 型
        final int hash;                   // 宣告 hash 值為 final 型 
        volatile V value;                 // 宣告 value 為 volatile 型
        final HashEntry<K,V> next;      // 宣告 next 為 final 型 

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

 static final class Segment<K,V> extends ReentrantLock implements Serializable { 
        /** 
         * 在本 segment 範圍內，包含的 HashEntry 元素的個數
         * 該變數被宣告為 volatile 型
         */ 
        transient volatile int count; 

        /** 
         * table 被更新的次數
         */ 
        transient int modCount; 

        /** 
         * 當 table 中包含的 HashEntry 元素的個數超過本變數值時，觸發 table 的再雜湊
         */ 
        transient int threshold; 

        /** 
         * table 是由 HashEntry 物件組成的陣列
         * 如果雜湊時發生碰撞，碰撞的 HashEntry 物件就以連結串列的形式連結成一個連結串列
         * table 陣列的陣列成員代表雜湊對映表的一個桶
         * 每個 table 守護整個 ConcurrentHashMap 包含桶總數的一部分
         * 如果併發級別為 16，table 則守護 ConcurrentHashMap 包含的桶總數的 1/16 
         */ 
        transient volatile HashEntry<K,V>[] table; 

        /** 
         * 裝載因子
         */ 
        final float loadFactor; 

        Segment(int initialCapacity, float lf) { 
            loadFactor = lf; 
            setTable(HashEntry.<K,V>newArray(initialCapacity)); 
        } 

        /** 
         * 設定 table 引用到這個新生成的 HashEntry 陣列
         * 只能在持有鎖或建構函式中呼叫本方法
         */ 
        void setTable(HashEntry<K,V>[] newTable) { 
            // 計算臨界閥值為新陣列的長度與裝載因子的乘積
            threshold = (int)(newTable.length * loadFactor); 
            table = newTable; 
        } 

        /** 
         * 根據 key 的雜湊值，找到 table 中對應的那個桶（table 陣列的某個陣列成員）
         */ 
        HashEntry<K,V> getFirst(int hash) { 
            HashEntry<K,V>[] tab = table; 
            // 把雜湊值與 table 陣列長度減 1 的值相“與”，
 // 得到雜湊值對應的 table 陣列的下標
            // 然後返回 table 陣列中此下標對應的 HashEntry 元素
            return tab[hash & (tab.length - 1)]; 
        } 
 }

 public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> 
        implements ConcurrentMap<K, V>, Serializable { 

    /** 
     * 雜湊對映表的預設初始容量為 16，即初始預設為 16 個桶
     * 在建構函式中沒有指定這個引數時，使用本引數
     */ 
    static final 	 int DEFAULT_INITIAL_CAPACITY= 16; 

    /** 
     * 雜湊對映表的預設裝載因子為 0.75，該值是 table 中包含的 HashEntry 元素的個數與
 * table 陣列長度的比值
     * 當 table 中包含的 HashEntry 元素的個數超過了 table 陣列的長度與裝載因子的乘積時，
 * 將觸發 再雜湊
     * 在建構函式中沒有指定這個引數時，使用本引數
     */ 
    static final float DEFAULT_LOAD_FACTOR= 0.75f; 

    /** 
     * 雜湊表的預設併發級別為 16。該值表示當前更新執行緒的估計數
     * 在建構函式中沒有指定這個引數時，使用本引數
     */ 
    static final int DEFAULT_CONCURRENCY_LEVEL= 16; 

    /** 
     * segments 的掩碼值
     * key 的雜湊碼的高位用來選擇具體的 segment 
     */ 
    final int segmentMask; 

    /** 
     * 偏移量
     */ 
    final int segmentShift; 

    /** 
     * 由 Segment 物件組成的陣列
     */ 
    final Segment<K,V>[] segments; 

    /** 
     * 建立一個帶有指定初始容量、載入因子和併發級別的新的空對映。
     */ 
    public ConcurrentHashMap(int initialCapacity, 
                             float loadFactor, int concurrencyLevel) { 
        if(!(loadFactor > 0) || initialCapacity < 0 || 
 concurrencyLevel <= 0) 
            throw new IllegalArgumentException(); 

        if(concurrencyLevel > MAX_SEGMENTS) 
            concurrencyLevel = MAX_SEGMENTS; 

        // 尋找最佳匹配引數（不小於給定引數的最接近的 2 次冪） 
        int sshift = 0; 
        int ssize = 1; 
        while(ssize < concurrencyLevel) { 
            ++sshift; 
            ssize <<= 1; 
        } 
        segmentShift = 32 - sshift;       // 偏移量值
        segmentMask = ssize - 1;           // 掩碼值 
        this.segments = Segment.newArray(ssize);   // 建立陣列

        if (initialCapacity > MAXIMUM_CAPACITY) 
            initialCapacity = MAXIMUM_CAPACITY; 
        int c = initialCapacity / ssize; 
        if(c * ssize < initialCapacity) 
            ++c; 
        int cap = 1; 
        while(cap < c) 
            cap <<= 1; 

        // 依次遍歷每個陣列元素
        for(int i = 0; i < this.segments.length; ++i) 
            // 初始化每個陣列元素引用的 Segment 物件
 this.segments[i] = new Segment<K,V>(cap, loadFactor); 
    } 

    /** 
     * 建立一個帶有預設初始容量 (16)、預設載入因子 (0.75) 和 預設併發級別 (16) 
  * 的空雜湊對映表。
     */ 
    public ConcurrentHashMap() { 
        // 使用三個預設引數，呼叫上面過載的建構函式來建立空雜湊對映表
 this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); 
 }

 public V put(K key, V value) { 
        if (value == null)          //ConcurrentHashMap 中不允許用 null 作為對映值
            throw new NullPointerException(); 
        int hash = hash(key.hashCode());        // 計算鍵對應的雜湊碼
        // 根據雜湊碼找到對應的 Segment 
        return segmentFor(hash).put(key, hash, value, false); 
 }

 /** 
     * 使用 key 的雜湊碼來得到 segments 陣列中對應的 Segment 
     */ 
 final Segment<K,V> segmentFor(int hash) { 
    // 將雜湊值右移 segmentShift 個位，並在高位填充 0 
    // 然後把得到的值與 segmentMask 相“與”
 // 從而得到 hash 值對應的 segments 陣列的下標值
 // 最後根據下標值返回雜湊碼對應的 Segment 物件
        return segments[(hash >>> segmentShift) & segmentMask]; 
 }

 V put(K key, int hash, V value, boolean onlyIfAbsent) { 
            lock();  // 加鎖，這裡是鎖定某個 Segment 物件而非整個 ConcurrentHashMap 
            try { 
                int c = count; 

                if (c++ > threshold)     // 如果超過再雜湊的閾值
                    rehash();              // 執行再雜湊，table 陣列的長度將擴充一倍

                HashEntry<K,V>[] tab = table; 
                // 把雜湊碼值與 table 陣列的長度減 1 的值相“與”
                // 得到該雜湊碼對應的 table 陣列的下標值
                int index = hash & (tab.length - 1); 
                // 找到雜湊碼對應的具體的那個桶
                HashEntry<K,V> first = tab[index]; 

                HashEntry<K,V> e = first; 
                while (e != null && (e.hash != hash || !key.equals(e.key))) 
                    e = e.next; 

                V oldValue; 
                if (e != null) {            // 如果鍵 / 值對以經存在
                    oldValue = e.value; 
                    if (!onlyIfAbsent) 
                        e.value = value;    // 設定 value 值
                } 
                else {                        // 鍵 / 值對不存在 
                    oldValue = null; 
                    ++modCount;         // 要新增新節點到連結串列中，所以 modCont 要加 1  
                    // 建立新節點，並新增到連結串列的頭部 
                    tab[index] = new HashEntry<K,V>(key, hash, first, value); 
                    count = c;               // 寫 count 變數
                } 
                return oldValue; 
            } finally { 
                unlock();                     // 解鎖
            } 
        }

 V remove(Object key, int hash, Object value) { 
            lock();         // 加鎖
            try{ 
                int c = count - 1; 
                HashEntry<K,V>[] tab = table; 
                // 根據雜湊碼找到 table 的下標值
                int index = hash & (tab.length - 1); 
                // 找到雜湊碼對應的那個桶
                HashEntry<K,V> first = tab[index]; 
                HashEntry<K,V> e = first; 
                while(e != null&& (e.hash != hash || !key.equals(e.key))) 
                    e = e.next; 

                V oldValue = null; 
                if(e != null) { 
                    V v = e.value; 
                    if(value == null|| value.equals(v)) { // 找到要刪除的節點
                        oldValue = v; 
                        ++modCount; 
                        // 所有處於待刪除節點之後的節點原樣保留在連結串列中
                        // 所有處於待刪除節點之前的節點被克隆到新連結串列中
                        HashEntry<K,V> newFirst = e.next;// 待刪節點的後繼結點
                        for(HashEntry<K,V> p = first; p != e; p = p.next) 
                            newFirst = new HashEntry<K,V>(p.key, p.hash, 
                                                          newFirst, p.value); 
                        // 把桶連結到新的頭結點
                        // 新的頭結點是原連結串列中，刪除節點之前的那個節點
                        tab[index] = newFirst; 
                        count = c;      // 寫 count 變數
                    } 
                } 
                return oldValue; 
            } finally{ 
                unlock();               // 解鎖
            } 
        }

 transient volatile int count;

 V get(Object key, int hash) { 
            if(count != 0) {       // 首先讀 count 變數
                HashEntry<K,V> e = getFirst(hash); 
                while(e != null) { 
                    if(e.hash == hash && key.equals(e.key)) { 
                        V v = e.value; 
                        if(v != null)            
                            return v; 
                        // 如果讀到 value 域為 null，說明發生了重排序，加鎖後重新讀取
                        return readValueUnderLock(e); 
                    } 
                    e = e.next; 
                } 
            } 
            return null; 
        }