ConcurrentHashMap執行緒安全機制以及原始碼分析

1. JDK8中基於HashEntry（首節點）進行執行緒安全同步保證(在首節點進行加鎖)

2. 通過Node＋CAS＋Synchronized機制來完成

 

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        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;
        }

put操作

    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                //如果長度為0，需要對陣列進行初始化
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//如果沒有發生hash衝突，則會被封裝成一個Node節點，放置到陣列下標所對應的位置上面
                //通過CAS進行放置，因為在多執行緒的情況下，可能同時有多個執行緒想對同一個位置進行放入節點的操作
                //保證只有一個執行緒把節點放入到正確的位置上
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //如果concurrentHashMap正在移動，比如正在擴容，需要呼叫helpTransfer將節點放入至正確的位置:流程是類似的
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            //表示目標位置已經有元素了，也即發生了hash衝突。通過拉鍊法解決衝突
            else {
                V oldVal = null;
                //利用了synchronized對頭節點進行了鎖定，保證只有一個執行緒能進行拉鍊法
                synchronized (f) {
                	//接下來的操作和hashMap中的是類似的
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                        
    

get操作

    public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            else if (eh < 0)
                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;
    }

沒有使用任何的同步或者cas機制來保證執行緒安全

為什麼get不需要加鎖?

1. 由於Node的元素val和指標next是用volatile修飾的，執行緒A修改一個結點或者新增一個節點的時候，對執行緒B可見的
2. 陣列同時也使用volatile修飾，保證在陣列擴容的時候保證可見性
3. 對key和value包裹的Node中hash、key都是用final進行了修飾，意味著建立了以後就不能再進行修改了

總結

1. 在JDK8中ConcurrentHashMap的get操作全程不需要加鎖，put操作通過CAS+Synchronized關鍵字來保證執行緒安全
2.  這樣的設計機制保證了，它比其他同步容器如HashTable、Collections.synchronizedMap（）進行包裝效率高的原因