ConcurrentHashMap源碼閱讀

面試時面試官最常問的幾個問題：

1. HashMap是線程安全的嗎？

    答：不是。

2. 既然HashMap不是線程安全的，那有什麼替代方案？

    （1）用HashTable，它是線程安全的，但是被棄用了（性能問題被棄用了）。

    （2）用HashMap，但是所有調用它方法的地方，都做加鎖處理操作。

    （3）用ConcurrentHashMap，一了百了。

3. 爲什麼HashTable被棄用了？

    因爲它底層只是對所有HashMap方法進行了重寫（Synchronized修飾），並沒有做很多優h化。

4. ConcurrentHashMap怎麼做到線程安全的？

    接下來，我們要解決的就是這個問題。

首先熟悉下ConcurrentHashMap的數據結構（數組+鏈表+紅黑樹），桶中的結構可能是鏈表，也可能是紅黑樹，紅黑樹是爲了提高查找效率，如下圖：

接下來，我們來看看ConcurrentHashMap的構造方法：

    public ConcurrentHashMap() {
    }

    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        putAll(m);
    }

    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }

    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }

重點關注第五個構造方法，它有三個參數：initialCapacity是初始容量，loadFactor是加載因子，concurrencyLevel是併發級別，默認值爲16。

接下來，我們看看put()方法分別是怎麼實現的：

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

final V putVal(K key, V value, boolean onlyIfAbsent) {
		//不允許 key或value爲null
    if (key == null || value == null) throw new NullPointerException();
    //計算hash值
    int hash = spread(key.hashCode());
    int binCount = 0;
    //死循環 何時插入成功 何時跳出
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        //如果table爲空的話，初始化table
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        //根據hash值計算出在table裏面的位置 
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        	//如果這個位置沒有值 ，直接放進去，不需要加鎖
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        //當遇到表連接點時，需要進行整合表的操作
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            //結點上鎖  這裏的結點可以理解爲hash值相同組成的鏈表的頭結點
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    //fh〉0 說明這個節點是一個鏈表的節點 不是樹的節點
                    if (fh >= 0) {
                        binCount = 1;
                        //在這裏遍歷鏈表所有的結點
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            //如果hash值和key值相同  則修改對應結點的value值
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            //如果遍歷到了最後一個結點，那麼就證明新的節點需要插入 就把它插入在鏈表尾部
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    //如果這個節點是樹節點，就按照樹的方式插入值
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
            	//如果鏈表長度已經達到臨界值8 就需要把鏈表轉換爲樹結構
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //將當前ConcurrentHashMap的元素數量+1
    addCount(1L, binCount);
    return null;
}
    

比較明顯的就是，ConcurrentHashMap不接受空值了，key和value都不允許爲空。而且，ConcurrentHashMap對數據存儲做了優化，進行了數據分片加鎖處理。上面的代碼中，雖然也用到了Synchronized關鍵字，但是但是對某一個數據節點加鎖，並不會影響其他數據節點。

我們再來看看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;
    }

因爲get()方法不會對數據本身產生影響，所以並沒有加鎖的操作。

其實最需要注意的其實是size()方法：

    public int size() {
        long n = sumCount();
        return ((n < 0L) ? 0 :
                (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
                (int)n);
    }

    final long sumCount() {
        CounterCell[] as = counterCells; CounterCell a;
        long sum = baseCount;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

 size()方法並沒有加鎖操作，而是通過sumCount()方法把所有的數據片段的數據數量計算出來。