JDK8的版本，與JDK6的版本有很大的差異。實現執行緒安全的思想也已經完全變了，它摒棄了Segment（鎖段）的概念，而是啟用了一種全新的方式實現,利用CAS演算法。它沿用了與它同時期的HashMap版本的思想，底層依然由“陣列”+連結串列+紅黑樹的方式思想，但是為了做到併發，又增加了很多輔助的類，例如TreeBin，Traverser等物件內部類。CAS演算法實現無鎖化的修改值的操作，他可以大大降低鎖代理的效能消耗。這個演算法的基本思想就是不斷地去比較當前記憶體中的變數值與你指定的一個變數值是否相等，如果相等，則接受你指定的修改的值，否則拒絕你的操作。因為當前執行緒中的值已經不是最新的值，你的修改很可能會覆蓋掉其他執行緒修改的結果。這一點與樂觀鎖，SVN的思想是比較類似的。

ConcurrentHashMap是conccurrent家族中的一個類，由於它可以高效地支援併發操作，以及被廣泛使用，經典的開源框架Spring的底層資料結構就是使用ConcurrentHashMap實現的。與同是執行緒安全的老大哥HashTable相比，它已經更勝一籌，因此它的鎖更加細化，而不是像HashTable一樣為幾乎每個方法都添加了synchronized鎖，這樣的鎖無疑會影響到效能。

本文的分析的原始碼是JDK8的版本，與JDK6的版本有很大的差異。實現執行緒安全的思想也已經完全變了，它摒棄了Segment（鎖段）的概念，而是啟用了一種全新的方式實現,利用CAS演算法。它沿用了與它同時期的HashMap版本的思想，底層依然由“陣列”+連結串列+紅黑樹的方式思想，但是為了做到併發，又增加了很多輔助的類，例如TreeBin，Traverser等物件內部類。

1 重要的屬性

首先來看幾個重要的屬性，與HashMap相同的就不再介紹了，這裡重點解釋一下sizeCtl這個屬性。可以說它是ConcurrentHashMap中出鏡率很高的一個屬性，因為它是一個控制識別符號，在不同的地方有不同用途，而且它的取值不同，也代表不同的含義。

• 負數代表正在進行初始化或擴容操作

• -1代表正在初始化

• -N 表示有N-1個執行緒正在進行擴容操作

• 正數或0代表hash表還沒有被初始化，這個數值表示初始化或下一次進行擴容的大小，這一點類似於擴容閾值的概念。還後面可以看到，它的值始終是當前ConcurrentHashMap容量的0.75倍，這與loadfactor是對應的。

1. /** 
2.    * 盛裝Node元素的陣列 它的大小是2的整數次冪 
3.    * Size is always a power of two. Accessed directly by iterators. 
4.    */  
5.   transient volatile Node<K,V>[] table;  
6. /** 
7.    * Table initialization and resizing control.  When negative, the 
8.    * table is being initialized or resized: -1 for initialization, 
9.    * else -(1 + the number of active resizing threads).  Otherwise, 
10.    * when table is null, holds the initial table size to use upon 
11.    * creation, or 0 for default. After initialization, holds the 
12.    * next element count value upon which to resize the table. 
13.    hash表初始化或擴容時的一個控制位標識量。 
14.    負數代表正在進行初始化或擴容操作 
15.    -1代表正在初始化 
16.    -N 表示有N-1個執行緒正在進行擴容操作 
17.    正數或0代表hash表還沒有被初始化，這個數值表示初始化或下一次進行擴容的大小 
18.    */  
19.   private transient volatile int sizeCtl;   
20.   // 以下兩個是用來控制擴容的時候 單執行緒進入的變數  
21.    /** 
22.    * The number of bits used for generation stamp in sizeCtl. 
23.    * Must be at least 6 for 32bit arrays. 
24.    */  
25.   private static int RESIZE_STAMP_BITS = 16;  
26. /** 
27.    * The bit shift for recording size stamp in sizeCtl. 
28.    */  
29.   private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;  
30.   /* 
31.    * Encodings for Node hash fields. See above for explanation. 
32.    */  
33.   static final int MOVED     = -1; // hash值是-1，表示這是一個forwardNode節點  
34.   static final int TREEBIN   = -2; // hash值是-2  表示這時一個TreeBin節點  

2 重要的內部類

2.1 Node

Node是最核心的內部類，它包裝了key-value鍵值對，所有插入ConcurrentHashMap的資料都包裝在這裡面。它與HashMap中的定義很相似，但是但是有一些差別它對value和next屬性設定了volatile同步鎖，它不允許呼叫setValue方法直接改變Node的value域，它增加了find方法輔助map.get()方法。

1. static class Node<K,V> implements Map.Entry<K,V> {  
2.        final int hash;  
3.        final K key;  
4.        volatile V val;//帶有同步鎖的value  
5.        volatile Node<K,V> next;//帶有同步鎖的next指標  
6.        Node(int hash, K key, V val, Node<K,V> next) {  
7.            this.hash = hash;  
8.            this.key = key;  
9.            this.val = val;  
10.            this.next = next;  
11.        }  
12.        public final K getKey()       { return key; }  
13.        public final V getValue()     { return val; }  
14.        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }  
15.        public final String toString(){ return key + "=" + val; }  
16.        //不允許直接改變value的值  
17.        public final V setValue(V value) {  
18.            throw new UnsupportedOperationException();  
19.        }  
20.        public final boolean equals(Object o) {  
21.            Object k, v, u; Map.Entry<?,?> e;  
22.            return ((o instanceof Map.Entry) &&  
23.                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&  
24.                    (v = e.getValue()) != null &&  
25.                    (k == key || k.equals(key)) &&  
26.                    (v == (u = val) || v.equals(u)));  
27.        }  
28.        /** 
29.         * Virtualized support for map.get(); overridden in subclasses. 
30.         */  
31.        Node<K,V> find(int h, Object k) {  
32.            Node<K,V> e = this;  
33.            if (k != null) {  
34.                do {  
35.                    K ek;  
36.                    if (e.hash == h &&  
37.                        ((ek = e.key) == k || (ek != null && k.equals(ek))))  
38.                        return e;  
39.                } while ((e = e.next) != null);  
40.            }  
41.            return null;  
42.        }  
43.    }  
44.    這個Node內部類與HashMap中定義的Node類很相似，但是有一些差別  
45.    它對value和next屬性設定了volatile同步鎖  
46.    它不允許呼叫setValue方法直接改變Node的value域  
47.    它增加了find方法輔助map.get()方法  

2.2 TreeNode

樹節點類，另外一個核心的資料結構。當連結串列長度過長的時候，會轉換為TreeNode。但是與HashMap不相同的是，它並不是直接轉換為紅黑樹，而是把這些結點包裝成TreeNode放在TreeBin物件中，由TreeBin完成對紅黑樹的包裝。而且TreeNode在ConcurrentHashMap整合自Node類，而並非HashMap中的整合自LinkedHashMap.Entry<K,V>類，也就是說TreeNode帶有next指標，這樣做的目的是方便基於TreeBin的訪問。

2.3 TreeBin

這個類並不負責包裝使用者的key、value資訊，而是包裝的很多TreeNode節點。它代替了TreeNode的根節點，也就是說在實際的ConcurrentHashMap“陣列”中，存放的是TreeBin物件，而不是TreeNode物件，這是與HashMap的區別。另外這個類還帶有了讀寫鎖。

這裡僅貼出它的構造方法。可以看到在構造TreeBin節點時，僅僅指定了它的hash值為TREEBIN常量，這也就是個標識為。同時也看到我們熟悉的紅黑樹構造方法

1. /** 
2.          * Creates bin with initial set of nodes headed by b. 
3.          */  
4.         TreeBin(TreeNode<K,V> b) {  
5.             super(TREEBIN, null, null, null);  
6.             this.first = b;  
7.             TreeNode<K,V> r = null;  
8.             for (TreeNode<K,V> x = b, next; x != null; x = next) {  
9.                 next = (TreeNode<K,V>)x.next;  
10.                 x.left = x.right = null;  
11.                 if (r == null) {  
12.                     x.parent = null;  
13.                     x.red = false;  
14.                     r = x;  
15.                 }  
16.                 else {  
17.                     K k = x.key;  
18.                     int h = x.hash;  
19.                     Class<?> kc = null;  
20.                     for (TreeNode<K,V> p = r;;) {  
21.                         int dir, ph;  
22.                         K pk = p.key;  
23.                         if ((ph = p.hash) > h)  
24.                             dir = -1;  
25.                         else if (ph < h)  
26.                             dir = 1;  
27.                         else if ((kc == null &&  
28.                                   (kc = comparableClassFor(k)) == null) ||  
29.                                  (dir = compareComparables(kc, k, pk)) == 0)  
30.                             dir = tieBreakOrder(k, pk);  
31.                             TreeNode<K,V> xp = p;  
32.                         if ((p = (dir <= 0) ? p.left : p.right) == null) {  
33.                             x.parent = xp;  
34.                             if (dir <= 0)  
35.                                 xp.left = x;  
36.                             else  
37.                                 xp.right = x;  
38.                             r = balanceInsertion(r, x);  
39.                             break;  
40.                         }  
41.                     }  
42.                 }  
43.             }  
44.             this.root = r;  
45.             assert checkInvariants(root);  
46.         }  

2.5 ForwardingNode

一個用於連線兩個table的節點類。它包含一個nextTable指標，用於指向下一張表。而且這個節點的key value next指標全部為null，它的hash值為-1. 這裡面定義的find的方法是從nextTable裡進行查詢節點，而不是以自身為頭節點進行查詢

1. /** 
2.      * A node inserted at head of bins during transfer operations. 
3.      */  
4.     static final class ForwardingNode<K,V> extends Node<K,V> {  
5.         final Node<K,V>[] nextTable;  
6.         ForwardingNode(Node<K,V>[] tab) {  
7.             super(MOVED, null, null, null);  
8.             this.nextTable = tab;  
9.         }  
10.         Node<K,V> find(int h, Object k) {  
11.             // loop to avoid arbitrarily deep recursion on forwarding nodes  
12.             outer: for (Node<K,V>[] tab = nextTable;;) {  
13.                 Node<K,V> e; int n;  
14.                 if (k == null || tab == null || (n = tab.length) == 0 ||  
15.                     (e = tabAt(tab, (n - 1) & h)) == null)  
16.                     return null;  
17.                 for (;;) {  
18.                     int eh; K ek;  
19.                     if ((eh = e.hash) == h &&  
20.                         ((ek = e.key) == k || (ek != null && k.equals(ek))))  
21.                         return e;  
22.                     if (eh < 0) {  
23.                         if (e instanceof ForwardingNode) {  
24.                             tab = ((ForwardingNode<K,V>)e).nextTable;  
25.                             continue outer;  
26.                         }  
27.                         else  
28.                             return e.find(h, k);  
29.                     }  
30.                     if ((e = e.next) == null)  
31.                         return null;  
32.                 }  
33.             }  
34.         }  
35.     }  

3 Unsafe與CAS

在ConcurrentHashMap中，隨處可以看到U, 大量使用了U.compareAndSwapXXX的方法，這個方法是利用一個CAS演算法實現無鎖化的修改值的操作，他可以大大降低鎖代理的效能消耗。這個演算法的基本思想就是不斷地去比較當前記憶體中的變數值與你指定的一個變數值是否相等，如果相等，則接受你指定的修改的值，否則拒絕你的操作。因為當前執行緒中的值已經不是最新的值，你的修改很可能會覆蓋掉其他執行緒修改的結果。這一點與樂觀鎖，SVN的思想是比較類似的。

3.1 unsafe靜態塊

unsafe程式碼塊控制了一些屬性的修改工作，比如最常用的SIZECTL 。  在這一版本的concurrentHashMap中，大量應用來的CAS方法進行變數、屬性的修改工作。  利用CAS進行無鎖操作，可以大大提高效能。

1. private static final sun.misc.Unsafe U;  
2.    private static final long SIZECTL;  
3.    private static final long TRANSFERINDEX;  
4.    private static final long BASECOUNT;  
5.    private static final long CELLSBUSY;  
6.    private static final long CELLVALUE;  
7.    private static final long ABASE;  
8.    private static final int ASHIFT;  
9.    static {  
10.        try {  
11.            U = sun.misc.Unsafe.getUnsafe();  
12.            Class<?> k = ConcurrentHashMap.class;  
13.            SIZECTL = U.objectFieldOffset  
14.                (k.getDeclaredField("sizeCtl"));  
15.            TRANSFERINDEX = U.objectFieldOffset  
16.                (k.getDeclaredField("transferIndex"));  
17.            BASECOUNT = U.objectFieldOffset  
18.                (k.getDeclaredField("baseCount"));  
19.            CELLSBUSY = U.objectFieldOffset  
20.                (k.getDeclaredField("cellsBusy"));  
21.            Class<?> ck = CounterCell.class;  
22.            CELLVALUE = U.objectFieldOffset  
23.                (ck.getDeclaredField("value"));  
24.            Class<?> ak = Node[].class;  
25.            ABASE = U.arrayBaseOffset(ak);  
26.            int scale = U.arrayIndexScale(ak);  
27.            if ((scale & (scale - 1)) != 0)  
28.                throw new Error("data type scale not a power of two");  
29.            ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);  
30.        } catch (Exception e) {  
31.            throw new Error(e);  
32.        }  
33.    }  

3.2 三個核心方法

ConcurrentHashMap定義了三個原子操作，用於對指定位置的節點進行操作。正是這些原子操作保證了ConcurrentHashMap的執行緒安全。

1. @SuppressWarnings("unchecked")  
2.    //獲得在i位置上的Node節點  
3.    static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {  
4.        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);  
5.    }  
6.     //利用CAS演算法設定i位置上的Node節點。之所以能實現併發是因為他指定了原來這個節點的值是多少  
7.     //在CAS演算法中，會比較記憶體中的值與你指定的這個值是否相等，如果相等才接受你的修改，否則拒絕你的修改  
8.     //因此當前執行緒中的值並不是最新的值，這種修改可能會覆蓋掉其他執行緒的修改結果  有點類似於SVN  
9.    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,  
10.                                        Node<K,V> c, Node<K,V> v) {  
11.        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);  
12.    }  
13.     //利用volatile方法設定節點位置的值  
14.    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {  
15.        U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);  
16.    }  

4 初始化方法initTable

對於ConcurrentHashMap來說，呼叫它的構造方法僅僅是設定了一些引數而已。而整個table的初始化是在向ConcurrentHashMap中插入元素的時候發生的。如呼叫put、computeIfAbsent、compute、merge等方法的時候，呼叫時機是檢查table==null。

初始化方法主要應用了關鍵屬性sizeCtl 如果這個值〈0，表示其他執行緒正在進行初始化，就放棄這個操作。在這也可以看出ConcurrentHashMap的初始化只能由一個執行緒完成。如果獲得了初始化許可權，就用CAS方法將sizeCtl置為-1，防止其他執行緒進入。初始化陣列後，將sizeCtl的值改為0.75*n

1. /** 
2.      * Initializes table, using the size recorded in sizeCtl. 
3.      */  
4.     private final Node<K,V>[] initTable() {  
5.         Node<K,V>[] tab; int sc;  
6.         while ((tab = table) == null || tab.length == 0) {  
7.                 //sizeCtl表示有其他執行緒正在進行初始化操作，把執行緒掛起。對於table的初始化工作，只能有一個執行緒在進行。  
8.             if ((sc = sizeCtl) < 0)  
9.                 Thread.yield(); // lost initialization race; just spin  
10.             else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//利用CAS方法把sizectl的值置為-1 表示本執行緒正在進行初始化  
11.                 try {  
12.                     if ((tab = table) == null || tab.length == 0) {  
13.                         int n = (sc > 0) ? sc : DEFAULT_CAPACITY;  
14.                         @SuppressWarnings("unchecked")  
15.                         Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];  
16.                         table = tab = nt;  
17.                         sc = n - (n >>> 2);//相當於0.75*n 設定一個擴容的閾值  
18.                     }  
19.                 } finally {  
20.                     sizeCtl = sc;  
21.                 }  
22.                 break;  
23.             }  
24.         }  
25.         return tab;  
26.     }  

5 擴容方法 transfer

當ConcurrentHashMap容量不足的時候，需要對table進行擴容。這個方法的基本思想跟HashMap是很像的，但是由於它是支援併發擴容的，所以要複雜的多。原因是它支援多執行緒進行擴容操作，而並沒有加鎖。我想這樣做的目的不僅僅是為了滿足concurrent的要求，而是希望利用併發處理去減少擴容帶來的時間影響。因為在擴容的時候，總是會涉及到從一個“陣列”到另一個“陣列”拷貝的操作，如果這個操作能夠併發進行，那真真是極好的了。

整個擴容操作分為兩個部分

•  第一部分是構建一個nextTable,它的容量是原來的兩倍，這個操作是單執行緒完成的。這個單執行緒的保證是通過RESIZE_STAMP_SHIFT這個常量經過一次運算來保證的，這個地方在後面會有提到；

• 第二個部分就是將原來table中的元素複製到nextTable中，這裡允許多執行緒進行操作。

先來看一下單執行緒是如何完成的：

它的大體思想就是遍歷、複製的過程。首先根據運算得到需要遍歷的次數i，然後利用tabAt方法獲得i位置的元素：

• 如果這個位置為空，就在原table中的i位置放入forwardNode節點，這個也是觸發併發擴容的關鍵點；

• 如果這個位置是Node節點（fh>=0），如果它是一個連結串列的頭節點，就構造一個反序連結串列，把他們分別放在nextTable的i和i+n的位置上

• 如果這個位置是TreeBin節點（fh<0），也做一個反序處理，並且判斷是否需要untreefi，把處理的結果分別放在nextTable的i和i+n的位置上

• 遍歷過所有的節點以後就完成了複製工作，這時讓nextTable作為新的table，並且更新sizeCtl為新容量的0.75倍 ，完成擴容。

再看一下多執行緒是如何完成的：

在程式碼的69行有一個判斷，如果遍歷到的節點是forward節點，就向後繼續遍歷，再加上給節點上鎖的機制，就完成了多執行緒的控制。多執行緒遍歷節點，處理了一個節點，就把對應點的值set為forward，另一個執行緒看到forward，就向後遍歷。這樣交叉就完成了複製工作。而且還很好的解決了執行緒安全的問題。 這個方法的設計實在是讓我膜拜。

1.  /** 
2.     * 一個過渡的table表  只有在擴容的時候才會使用 
3.     */  
4.    private transient volatile Node<K,V>[] nextTable;  
5. /** 
6.     * Moves and/or copies the nodes in each bin to new table. See 
7.     * above for explanation. 
8.     */  
9.    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {  
10.        int n = tab.length, stride;  
11.        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)  
12.            stride = MIN_TRANSFER_STRIDE; // subdivide range  
13.        if (nextTab == null) {            // initiating  
14.            try {  
15.                @SuppressWarnings("unchecked")  
16.                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];//構造一個nextTable物件 它的容量是原來的兩倍  
17.                nextTab = nt;  
18.            } catch (Throwable ex) {      // try to cope with OOME  
19.                sizeCtl = Integer.MAX_VALUE;  
20.                return;  
21.            }  
22.            nextTable = nextTab;  
23.            transferIndex = n;  
24.        }  
25.        int nextn = nextTab.length;  
26.        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);//構造一個連節點指標 用於標誌位  
27.        boolean advance = true;//併發擴容的關鍵屬性 如果等於true 說明這個節點已經處理過  
28.        boolean finishing = false; // to ensure sweep before committing nextTab  
29.        for (int i = 0, bound = 0;;) {  
30.            Node<K,V> f; int fh;  
31.            //這個while迴圈體的作用就是在控制i--  通過i--可以依次遍歷原hash表中的節點  
32.            while (advance) {  
33.                int nextIndex, nextBound;  
34.                if (--i >= bound || finishing)  
35.                    advance = false;  
36.                else if ((nextIndex = transferIndex) <= 0) {  
37.                    i = -1;  
38.                    advance = false;  
39.                }  
40.                else if (U.compareAndSwapInt  
41.                         (this, TRANSFERINDEX, nextIndex,  
42.                          nextBound = (nextIndex > stride ?  
43.                                       nextIndex - stride : 0))) {  
44.                    bound = nextBound;  
45.                    i = nextIndex - 1;  
46.                    advance = false;  
47.                }  
48.            }  
49.            if (i < 0 || i >= n || i + n >= nextn) {  
50.                int sc;  
51.                if (finishing) {  
52.                 //如果所有的節點都已經完成複製工作  就把nextTable賦值給table 清空臨時物件nextTable  
53.                    nextTable = null;  
54.                    table = nextTab;  
55.                    sizeCtl = (n << 1) - (n >>> 1);//擴容閾值設定為原來容量的1.5倍  依然相當於現在容量的0.75倍  
56.                    return;  
57.                }  
58.                //利用CAS方法更新這個擴容閾值，在這裡面sizectl值減一，說明新加入一個執行緒參與到擴容操作  
59.                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {  
60.                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)  
61.                        return;  
62.                    finishing = advance = true;  
63.                    i = n; // recheck before commit  
64.                }  
65.            }  
66.            //如果遍歷到的節點為空 則放入ForwardingNode指標  
67.            else if ((f = tabAt(tab, i)) == null)  
68.                advance = casTabAt(tab, i, null, fwd);  
69.            //如果遍歷到ForwardingNode節點  說明這個點已經被處理過了 直接跳過  這裡是控制併發擴容的核心  
70.            else if ((fh = f.hash) == MOVED)  
71.                advance = true; // already processed  
72.            else {  
73.                 //節點上鎖  
74.                synchronized (f) {  
75.                    if (tabAt(tab, i) == f) {  
76.                        Node<K,V> ln, hn;  
77.                        //如果fh>=0 證明這是一個Node節點  
78.                        if (fh >= 0) {  
79.                            int runBit = fh & n;  
80.                            //以下的部分在完成的工作是構造兩個連結串列  一個是原連結串列  另一個是原連結串列的反序排列  
81.                            Node<K,V> lastRun = f;  
82.                            for (Node<K,V> p = f.next; p != null; p = p.next) {  
83.                                int b = p.hash & n;  
84.                                if (b != runBit) {  
85.                                    runBit = b;  
86.                                    lastRun = p;  
87.                                }  
88.                            }  
89.                            if (runBit == 0) {  
90.                                ln = lastRun;  
91.                                hn = null;  
92.                            }  
93.                            else {  
94.                                hn = lastRun;  
95.                                ln = null;  
96.                            }  
97.                            for (Node<K,V> p = f; p != lastRun; p = p.next) {  
98.                                int ph = p.hash; K pk = p.key; V pv = p.val;  
99.                                if ((ph & n) == 0)  
100.                                    ln = new Node<K,V>(ph, pk, pv, ln);  
101.                                else  
102.                                    hn = new Node<K,V>(ph, pk, pv, hn);  
103.                            }  
104.                            //在nextTable的i位置上插入一個連結串列  
105.                            setTabAt(nextTab, i, ln);  
106.                            //在nextTable的i+n的位置上插入另一個連結串列  
107.                            setTabAt(nextTab, i + n, hn);  
108.                            //在table的i位置上插入forwardNode節點  表示已經處理過該節點  
109.                            setTabAt(tab, i, fwd);  
110.                            //設定advance為true 返回到上面的while迴圈中 就可以執行i--操作  
111.                            advance = true;  
112.                        }  
113.                        //對TreeBin物件進行處理  與上面的過程類似  
114.                        else if (f instanceof TreeBin) {  
115.                            TreeBin<K,V> t = (TreeBin<K,V>)f;  
116.                            TreeNode<K,V> lo = null, loTail = null;  
117.                            TreeNode<K,V> hi = null, hiTail = null;  
118.                            int lc = 0, hc = 0;  
119.                            //構造正序和反序兩個連結串列  
120.                            for (Node<K,V> e = t.first; e != null; e = e.next) {  
121.                                int h = e.hash;  
122.                                TreeNode<K,V> p = new TreeNode<K,V>  
123.                                    (h, e.key, e.val, null, null);  
124.                                if ((h & n) == 0) {  
125.                                    if ((p.prev = loTail) == null)  
126.                                        lo = p;  
127.                                    else  
128.                                        loTail.next = p;  
129.                                    loTail = p;  
130.                                    ++lc;  
131.                                }  
132.                                else {  
133.                                    if ((p.prev = hiTail) == null)  
134.                                        hi = p;  
135.                                    else  
136.                                        hiTail.next = p;  
137.                                    hiTail = p;  
138.                                    ++hc;  
139.                                }  
140.                            }  
141.                            //如果擴容後已經不再需要tree的結構 反向轉換為連結串列結構  
142.                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :  
143.                                (hc != 0) ? new TreeBin<K,V>(lo) : t;  
144.                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :  
145.                                (lc != 0) ? new TreeBin<K,V>(hi) : t;  
146.                             //在nextTable的i位置上插入一個連結串列      
147.                            setTabAt(nextTab, i, ln);  
148.                            //在nextTable的i+n的位置上插入另一個連結串列  
149.                            setTabAt(nextTab, i + n, hn);  
150.                             //在table的i位置上插入forwardNode節點  表示已經處理過該節點  
151.                            setTabAt(tab, i, fwd);  
152.                            //設定advance為true 返回到上面的while迴圈中 就可以執行i--操作  
153.                            advance = true;  
154.                        }  
155.                    }  
156.                }  
157.            }  
158.        }  
159.    }  

6 Put方法

前面的所有的介紹其實都為這個方法做鋪墊。ConcurrentHashMap最常用的就是put和get兩個方法。現在來介紹put方法，這個put方法依然沿用HashMap的put方法的思想，根據hash值計算這個新插入的點在table中的位置i，如果i位置是空的，直接放進去，否則進行判斷，如果i位置是樹節點，按照樹的方式插入新的節點，否則把i插入到連結串列的末尾。ConcurrentHashMap中依然沿用這個思想，有一個最重要的不同點就是ConcurrentHashMap不允許key或value為null值。另外由於涉及到多執行緒，put方法就要複雜一點。在多執行緒中可能有以下兩個情況

1. 如果一個或多個執行緒正在對ConcurrentHashMap進行擴容操作，當前執行緒也要進入擴容的操作中。這個擴容的操作之所以能被檢測到，是因為transfer方法中在空結點上插入forward節點，如果檢測到需要插入的位置被forward節點佔有，就幫助進行擴容；

2. 如果檢測到要插入的節點是非空且不是forward節點，就對這個節點加鎖，這樣就保證了執行緒安全。儘管這個有一些影響效率，但是還是會比hashTable的synchronized要好得多。

整體流程就是首先定義不允許key或value為null的情況放入  對於每一個放入的值，首先利用spread方法對key的hashcode進行一次hash計算，由此來確定這個值在table中的位置。

如果這個位置是空的，那麼直接放入，而且不需要加鎖操作。

    如果這個位置存在結點，說明發生了hash碰撞，首先判斷這個節點的型別。如果是連結串列節點（fh>0）,則得到的結點就是hash值相同的節點組成的連結串列的頭節點。需要依次向後遍歷確定這個新加入的值所在位置。如果遇到hash值與key值都與新加入節點是一致的情況，則只需要更新value值即可。否則依次向後遍歷，直到連結串列尾插入這個結點。  如果加入這個節點以後連結串列長度大於8，就把這個連結串列轉換成紅黑樹。如果這個節點的型別已經是樹節點的話，直接呼叫樹節點的插入方法進行插入新的值。[java] view plain copy

1. public V put(K key, V value) {  
2.         return putVal(key, value, false);  
3.     }  
4.     /** Implementation for put and putIfAbsent */  
5.     final V putVal(K key, V value, boolean onlyIfAbsent) {  
6.             //不允許 key或value為null  
7.         if (key == null || value == null) throw new NullPointerException();  
8.         //計算hash值  
9.         int hash = spread(key.hashCode());  
10.         int binCount = 0;  
11.         //死迴圈 何時插入成功 何時跳出  
12.         for (Node<K,V>[] tab = table;;) {  
13.             Node<K,V> f; int n, i, fh;  
14.             //如果table為空的話，初始化table  
15.             if (tab == null || (n = tab.length) == 0)  
16.                 tab = initTable();  
17.             //根據hash值計算出在table裡面的位置   
18.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {  
19.                 //如果這個位置沒有值 ，直接放進去，不需要加鎖  
20.                 if (casTabAt(tab, i, null,  
21.                              new Node<K,V>(hash, key, value, null)))  
22.                     break;                   // no lock when adding to empty bin  
23.             }  
24.             //當遇到表連線點時，需要進行整合表的操作  
25.             else if ((fh = f.hash) == MOVED)  
26.                 tab = helpTransfer(tab, f);  
27.             else {  
28.                 V oldVal = null;  
29.                 //結點上鎖  這裡的結點可以理解為hash值相同組成的連結串列的頭結點  
30.                 synchronized (f) {  
31.                     if (tabAt(tab, i) == f) {  
32.                         //fh〉0 說明這個節點是一個連結串列的節點 不是樹的節點  
33.                         if (fh >= 0) {  
34.                             binCount = 1;  
35.                             //在這裡遍歷連結串列所有的結點  
36.                             for (Node<K,V> e = f;; ++binCount) {  
37.                                 K ek;  
38.                                 //如果hash值和key值相同  則修改對應結點的value值  
39.                                 if (e.hash == hash &&  
40.                                     ((ek = e.key) == key ||  
41.                                      (ek != null && key.equals(ek)))) {  
42.                                     oldVal = e.val;  
43.                                     if (!onlyIfAbsent)  
44.                                         e.val = value;  
45.                                     break;  
46.                                 }  
47.                                 Node<K,V> pred = e;  
48.                                 //如果遍歷到了最後一個結點，那麼就證明新的節點需要插入 就把它插入在連結串列尾部  
49.                                 if ((e = e.next) == null) {  
50.                                     pred.next = new Node<K,V>(hash, key,  
51.                                                               value, null);  
52.                                     break;  
53.                                 }  
54.                             }  
55.                         }  
56.                         //如果這個節點是樹節點，就按照樹的方式插入值  
57.                         else if (f instanceof TreeBin) {  
58.                             Node<K,V> p;  
59.                             binCount = 2;  
60.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,  
61.                                                            value)) != null) {  
62.                                 oldVal = p.val;  
63.                                 if (!onlyIfAbsent)  
64.                                     p.val = value;  
65.                             }  
66.                         }  
67.                     }  
68.                 }  
69.                 if (binCount != 0) {  
70.                     //如果連結串列長度已經達到臨界值8 就需要把連結串列轉換為樹結構  
71.                     if (binCount >= TREEIFY_THRESHOLD)  
72.                         treeifyBin(tab, i);  
73.                     if (oldVal != null)  
74.                         return oldVal;  
75.                     break;  
76.                 }  
77.             }  
78.         }  
79.         //將當前ConcurrentHashMap的元素數量+1  
80.         addCount(1L, binCount);  
81.         return null;  
82.     }  

6.1 helpTransfer方法

這是一個協助擴容的方法。這個方法被呼叫的時候，當前ConcurrentHashMap一定已經有了nextTable物件，首先拿到這個nextTable物件，呼叫transfer方法。回看上面的transfer方法可以看到，當本執行緒進入擴容方法的時候會直接進入複製階段。

1. /** 
2.     * Helps transfer if a resize is in progress. 
3.     */  
4.    final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {  
5.        Node<K,V>[] nextTab; int sc;  
6.        if (tab != null && (f instanceof ForwardingNode) &&  
7.            (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {  
8.            int rs = resizeStamp(tab.length);//計算一個操作校驗碼  
9.            while (nextTab == nextTable && table == tab &&  
10.                   (sc = sizeCtl) < 0) {  
11.                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||  
12.                    sc == rs + MAX_RESIZERS || transferIndex <= 0)  
13.                    break;  
14.                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {  
15.                    transfer(tab, nextTab);  
16.                    break;  
17.                }  
18.            }  
19.            return nextTab;  
20.        }  
21.        return table;  
22.    }  

6.2 treeifyBin方法

這個方法用於將過長的連結串列轉換為TreeBin物件。但是他並不是直接轉換，而是進行一次容量判斷，如果容量沒有達到轉換的要求，直接進行擴容操作並返回；如果滿足條件才連結串列的結構抓換為TreeBin ，這與HashMap不同的是，它並沒有把TreeNode直接放入紅黑樹，而是利用了TreeBin這個小容器來封裝所有的TreeNode.

1. private final void treeifyBin(Node<K,V>[] tab, int index) {  
2.         Node<K,V> b; int n, sc;  
3.         if (tab != null) {  
4.             if ((n = tab.length) < MIN_TREEIFY_CAPACITY)//如果table.length<64 就擴大一倍 返回  
5.                 tryPresize(n << 1);  
6.             else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {  
7.                 synchronized (b) {  
8.                     if (tabAt(tab, index) == b) {  
9.                         TreeNode<K,V> hd = null, tl = null;  
10.                         //構造了一個TreeBin物件 把所有Node節點包裝成TreeNode放進去  
11.                         for (Node<K,V> e = b; e != null; e = e.next) {  
12.                             TreeNode<K,V> p =  
13.                                 new TreeNode<K,V>(e.hash, e.key, e.val,  
14.                                                   null, null);//這裡只是利用了TreeNode封裝 而沒有利用TreeNode的next域和parent域  
15.                             if ((p.prev = tl) == null)  
16.                                 hd = p;  
17.                             else  
18.                                 tl.next = p;  
19.                             tl = p;  
20.                         }  
21.                         //在原來index的位置 用TreeBin替換掉原來的Node物件  
22.                         setTabAt(tab, index, new TreeBin<K,V>(hd));  
23.                     }  
24.                 }  
25.             }  
26.         }  
27.     }  

7 get方法

get方法比較簡單，給定一個key來確定value的時候，必須滿足兩個條件  key相同  hash值相同，對於節點可能在連結串列或樹上的情況，需要分別去查詢.

1. public V get(Object key) {  
2.         Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;  
3.         //計算hash值  
4.         int h = spread(key.hashCode());  
5.         //根據hash值確定節點位置  
6.         if ((tab = table) != null && (n = tab.length) > 0 &&  
7.             (e = tabAt(tab, (n - 1) & h)) != null) {  
8.             //如果搜尋到的節點key與傳入的key相同且不為null,直接返回這個節點    
9.             if ((eh = e.hash) == h) {  
10.                 if ((ek = e.key) == key || (ek != null && key.equals(ek)))  
11.                     return e.val;  
12.             }  
13.             //如果eh<0 說明這個節點在樹上 直接尋找  
14.             else if (eh < 0)  
15.                 return (p = e.find(h, key)) != null ? p.val : null;  
16.              //否則遍歷連結串列 找到對應的值並返回  
17.             while ((e = e.next) != null) {  
18.                 if (e.hash == h &&  
19.                     ((ek = e.key) == key || (ek != null && key.equals(ek))))  
20.                     return e.val;  
21.             }  
22.         }  
23.         return null;  
24.     }  

8 Size相關的方法

對於ConcurrentHashMap來說，這個table裡到底裝了多少東西其實是個不確定的數量，因為不可能在呼叫size()方法的時候像GC的“stop the world”一樣讓其他執行緒都停下來讓你去統計，因此只能說這個數量是個估計值。對於這個估計值，ConcurrentHashMap也是大費周章才計算出來的。

8.1 輔助定義

為了統計元素個數，ConcurrentHashMap定義了一些變數和一個內部類

1. /** 
2.      * A padded cell for distributing counts.  Adapted from LongAdder 
3.      * and Striped64.  See their internal docs for explanation. 
4.      */  
5.     @sun.misc.Contended static final class CounterCell {  
6.         volatile long value;  
7.         CounterCell(long x) { value = x; }  
8.     }  
9.   /******************************************/    
10.     /** 
11.      * 實際上儲存的是hashmap中的元素個數  利用CAS鎖進行更新 
12.      但它並不用返回當前hashmap的元素個數  
13.      */  
14.     private transient volatile long baseCount;  
15.     /** 
16.      * Spinlock (locked via CAS) used when resizing and/or creating CounterCells. 
17.      */  
18.     private transient volatile int cellsBusy;  
19.     /** 
20.      * Table of counter cells. When non-null, size is a power of 2. 
21.      */  
22.     private transient volatile CounterCell[] counterCells;  

8.2 mappingCount與Size方法

mappingCount與size方法的類似  從Java工程師給出的註釋來看，應該使用mappingCount代替size方法 兩個方法都沒有直接返回basecount 而是統計一次這個值，而這個值其實也是一個大概的數值，因此可能在統計的時候有其他執行緒正在執行插入或刪除操作。

1. public int size() {  
2.         long n = sumCount();  
3.         return ((n < 0L) ? 0 :  
4.                 (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :  
5.                 (int)n);  
6.     }  
7.      /** 
8.      * Returns the number of mappings. This method should be used 
9.      * instead of {@link #size} because a ConcurrentHashMap may 
10.      * contain more mappings than can be represented as an int. The 
11.      * value returned is an estimate; the actual count may differ if 
12.      * there are concurrent insertions or removals. 
13.      * 
14.      * @return the number of mappings 
15.      * @since 1.8 
16.      */  
17.     public long mappingCount() {  
18.         long n = sumCount();  
19.         return (n < 0L) ? 0L : n; // ignore transient negative values  
20.     }  
21.      final long sumCount() {  
22.         CounterCell[] as = counterCells; CounterCell a;  
23.         long sum = baseCount;  
24.         if (as != null) {  
25.             for (int i = 0; i < as.length; ++i) {  
26.                 if ((a = as[i]) != null)  
27.                     sum += a.value;//所有counter的值求和  
28.             }  
29.         }  
30.         return sum;  
31.     }  

8.3 addCount方法

在put方法結尾處呼叫了addCount方法，把當前ConcurrentHashMap的元素個數+1這個方法一共做了兩件事,更新baseCount的值，檢測是否進行擴容。

1. private final void addCount(long x, int check) {  
2.         CounterCell[] as; long b, s;  
3.         //利用CAS方法更新baseCount的值   
4.         if ((as = counterCells) != null ||  
5.             !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {  
6.             CounterCell a; long v; int m;  
7.             boolean uncontended = true;  
8.             if (as == null || (m = as.length - 1) < 0 ||  
9.                 (a = as[ThreadLocalRandom.getProbe() & m]) == null ||  
10.                 !(uncontended =  
11.                   U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {  
12.                 fullAddCount(x, uncontended);  
13.                 return;  
14.             }  
15.             if (check <= 1)  
16.                 return;  
17.             s = sumCount();  
18.         }  
19.         //如果check值大於等於0 則需要檢驗是否需要進行擴容操作  
20.         if (check >= 0) {  
21.             Node<K,V>[] tab, nt; int n, sc;  
22.             while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&  
23.                    (n = tab.length) < MAXIMUM_CAPACITY) {  
24.                 int rs = resizeStamp(n);  
25.                 //  
26.                 if (sc < 0) {  
27.                     if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||  
28.                         sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||  
29.                         transferIndex <= 0)  
30.                         break;  
31.                      //如果已經有其他執行緒在執行擴容操作  
32.                     if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))  
33.                         transfer(tab, nt);  
34.                 }  
35.                 //當前執行緒是唯一的或是第一個發起擴容的執行緒  此時nextTable=null  
36.                 else if (U.compareAndSwapInt(this, SIZECTL, sc,  
37.                                              (rs << RESIZE_STAMP_SHIFT) + 2))  
38.                     trans