JUC---ConcurrentHashMap源碼解析(JDK13)

java.util.concurrent包系列文章
JUC—ThreadLocal源碼解析(JDK13)
JUC—ThreadPoolExecutor線程池源碼解析(JDK13)
JUC—各種鎖(JDK13)
JUC—原子類Atomic*.java源碼解析(JDK13)
JUC—CAS源碼解析(JDK13)
JUC—ConcurrentHashMap源碼解析(JDK13)
JUC—CopyOnWriteArrayList源碼解析(JDK13)
JUC—併發隊列源碼解析(JDK13)
JUC—多線程下控制併發流程(JDK13)
JUC—AbstractQueuedSynchronizer解析(JDK13)

---

一、Map家族

本篇只分析ConcurrentHashMap的源碼。HashMap就簡略帶過，但是必須先明白了HashMap的相關原理再來了解ConcurrentHashMap更好。
Map是我們工作中用到最多的數據結構，key-value形式。看看整個Map家族

• HashMap，根據鍵值的hashcode尋找存儲位置，查詢的時候速度也非常快。線程非安全的。
• HashTable，在HashMap的基礎上爲每個方法加了synchronized修飾來保證線程安全。廢棄不使用。併發性能低。
• LinkedHashMap，保存記錄的插入順序，遍歷的時候也是根據插入順序遍歷的。常用在一些過濾器的註冊中，Shiro的自定義過濾器就用到了。
• TreeMap，實現了SortedMap，可以根據鍵排序。默認升序，可以自定義排序的實現。
• ConcurrentHashMap，線程安全的Map，在JDK1.7和JDK1.8及更高的版本實現不同。

// Collections工具類中的synchronizedMap方法也能獲得一個線程安全的Map，不過性能比ConcurrentHashMap低，也不推薦使用
// 在源碼可以發現，它也是用synchronized把所有方法包裝起來，類似HashTable
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
}

不管什麼Map，都要求key是不可變對象。如果key還可變的話，存儲，查詢都會根據key計算hash值，那Map豈不是混亂了。

HashMap爲什麼線程不安全？多線程下就不應該使用HashMap

同時碰撞可能會導致數據丟失，兩個線程put，如果計算的hash值一樣，那麼就有一個會丟失數據
同時擴容可能會導致數據丟失，兩個線程擴容resize，最後只會保存一個數組，也會丟失數據
死循環(JDK7及更低版本存在)，多個線程擴容的時候造成鏈表的死循環，環形鏈表

---

二、HashMap

JDK1.7及更低的版本

數組+鏈表的形式。產生Hash碰撞就採用拉鍊法。

相關圖片來自：https://www.javadoop.com/post/hashmap

JDK1.8及更高的版本

數組+鏈表+紅黑樹的形式。相比於1.7不同的是，產生Hash碰撞後，當鏈表長度超過8並且容量超過64就會轉爲紅黑樹。紅黑樹是一種平衡二叉樹，也叫二叉查找樹，會自動平衡節點。讓左右樹的高度差不超過1。達到一種平衡。左節點比右節點小。查詢效率是O(logN)。相比於鏈表的查詢效率O(N)，查詢速度更快。

在HashMap的put方法中有這樣一段代碼

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
	// 新插入的值是鏈表中的第8個，則轉爲紅黑樹
    treeifyBin(tab, hash);
break;

TREEIFY_THRESHOLD初始化值如下

static final int TREEIFY_THRESHOLD = 8;
static final int MIN_TREEIFY_CAPACITY = 64;

不過在treeifyBin方法還有一層判斷

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        // 桶數組的長度要大於64才轉爲紅黑樹，否則執行數組擴容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

爲什麼要達到一定長度才轉：紅黑樹佔用的內存是鏈表的2倍。衝突不多的情況下，用鏈表也無可厚非，速度差別忽略不計。而且很少有情況能鏈表長度超過8。

---

三、ConcurrentHashMap

JDK1.7

在1.7中ConcurrentHashMap採用分段鎖的思想。是一個Segment數組。初始化有16個Segment。Segment繼承了ReentrantLock來進行加鎖，所以每次需要加鎖的操作鎖住的是一個 segment，這樣只要保證每個 Segment 是線程安全的。每個Segment裏面可以看做一個類似於HashMap的結構。每個Segment不相互影響，最大允許16個線程的併發。初始化時可以設置Segment大小，不過設置之後不會擴容。

static final class Segment<K,V> extends ReentrantLock implements Serializable{}

JDK1.8及更高的版本，本文貼的代碼是JDK13

在1.8及更高的版本中ConcurrentHashMap和HashMap是非常相似的。兩者結構上基本上一樣，不過ConcurrentHashMap要保證線程安全性。

put(K key, V value)

public V put(K key, V value) {
     return putVal(key, value, false);
 }

 /** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
	// 與HashMap不一樣，key-value都不允許爲null
    if (key == null || value == null) throw new NullPointerException();
    // 得到鍵的hash值
    int hash = spread(key.hashCode());
    // 用於記錄相應鏈表的長度
    int binCount = 0;
    // 在for循環中完成值得put操作
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh; K fk; V fv;
        // 如果數組"空"，進行數組初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        	// 如果數組該位置爲空，直接用CAS操作設置值
            // casTabAt方法貼在下面。裏面調用Unsafe的本地方法。
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
            	// 如果CAS成功，本次put就結束了
            	// 如果CAS失敗，說明有另一個線程已經在這個位置put了值。那就是有併發操作，進到下一個循環就好了
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
        	// MOVED代表這個槽點正在擴容，那就去幫助擴容
            tab = helpTransfer(tab, f);
        else if (onlyIfAbsent // check first node without acquiring lock
                 && fh == hash
                 && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                 && (fv = f.val) != null)
            return fv;
        else {
        	// 到這裏就說明f是該位置的頭結點，而且不爲空
        	// oldVal是要返回的舊值
            V oldVal = null;
            // 加鎖，保證線程安全
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
						// 頭結點的hash 值大於0，說明是鏈表
                        // 用於累加，記錄鏈表的長度
                        binCount = 1;
                        // 遍歷鏈表
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 找到對應的位置，如果發現了相同的key，判斷是否要進行值覆蓋，然後就可以break結束了，退出for循環
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                // 把原來的值賦給oldVal 
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            // 沒有相同的key，就到了鏈表的最後，將這個新值放到鏈表的最後面，退出for循環
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                    	// 如果是紅黑樹
                        Node<K,V> p;
                        binCount = 2;
                        // 則把元素添加在樹上
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            // 把原來的值賦給oldVal 
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
            	// 判斷是否要將鏈表轉換爲紅黑樹，臨界值8
            	// 這個方法在上面HashMap1.8版本中有說道
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSetReference(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

put的流程：

• 判斷key value是否爲空
• 計算key的hash值
• 根據對應位置節點的類型來賦值，爲空就直接set，或者幫助擴容，是紅黑樹就直接增加元素到樹，是鏈表就添加到鏈表最後
• 判斷是否需要轉爲紅黑樹
• 返回舊值

利用CAS+synchronized 保證併發安全。

get(Object key)

public V get(Object key) {
     Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
     // 計算key的hash值
     int h = spread(key.hashCode());
     if ((tab = table) != null && (n = tab.length) > 0 &&
         (e = tabAt(tab, (n - 1) & h)) != null) {
         // 如果槽點hash值符合，並且key相等，就返回這個value
         if ((eh = e.hash) == h) {
             if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                 return e.val;
         }
         else if (eh < 0)
         	// 如果頭結點的hash小於0，說明正在擴容，或者該位置是紅黑樹
         	// 調用find方法查詢值
             return (p = e.find(h, key)) != null ? p.val : null;
         while ((e = e.next) != null) {
         	// 走到這裏的話就是鏈表，遍歷鏈表獲取值
             if (e.hash == h &&
                 ((ek = e.key) == key || (ek != null && key.equals(ek))))
                 return e.val;
         }
     }
     return null;
 }

Node<K,V> find(int h, Object k) {
  Node<K,V> e = this;
    if (k != null) {
    	// do while循環遍歷節點尋找value
        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;
}

get的流程：

• 計算key的hash值
• 根據對應槽點的類型取值，直接取值，紅黑樹取值，遍歷鏈表取值
• 返回value

---

• 我的公衆號：Coding摳腚
• 偶爾發發自己最近學到的乾貨。學習路線，經驗，技術分享。技術問題交流探討。