ConcurrentHashMap如何保證線程安全

之前看過HashMap的內部實現，知道HashMap是使用Node數組+鏈表+紅黑樹的數據結構來實現，以下圖所示。可是HashMap是非線程安全，在多線程環境不可以使用。

不過JDK在其併發包中爲咱們提供了線程安全的ConcurrentHashMap。所以，來學習如下其內部是如何保證線程安全的。

                                                               

                                                                                    HashMap的數據結構

1、Unsafe和CAS

 ConcurrentHashMap的大部分操做和HashMap是相同的，例如初始化，擴容和鏈表向紅黑樹的轉變等。可是，在ConcurrentHashMap中，大量使用了U.compareAndSwapXXX

的方法，這個方法是利用一個CAS算法實現無鎖化的修改值的操做，他能夠大大下降鎖代理的性能消耗。這個算法的基本思想就是不斷地去比較當前內存中的變量值與你指定的

一個變量值是否相等，若是相等，則接受你指定的修改的值，不然拒絕你的操做。由於當前線程中的值已經不是最新的值，你的修改極可能會覆蓋掉其餘線程修改的結果。這一

點與樂觀鎖，SVN的思想是比較相似的。

static {
    try {
        U = sun.misc.Unsafe.getUnsafe();
        Class<?> k = ConcurrentHashMap.class;
        SIZECTL = U.objectFieldOffset
            (k.getDeclaredField("sizeCtl"));
        TRANSFERINDEX = U.objectFieldOffset
            (k.getDeclaredField("transferIndex"));
        BASECOUNT = U.objectFieldOffset
            (k.getDeclaredField("baseCount"));
        CELLSBUSY = U.objectFieldOffset
            (k.getDeclaredField("cellsBusy"));
        Class<?> ck = CounterCell.class;
        CELLVALUE = U.objectFieldOffset
            (ck.getDeclaredField("value"));
        Class<?> ak = Node[].class;
        ABASE = U.arrayBaseOffset(ak);
        int scale = U.arrayIndexScale(ak);
        if ((scale & (scale - 1)) != 0)
            throw new Error("data type scale not a power of two");
        ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
    } catch (Exception e) {
        throw new Error(e);
    }
}

同時，在ConcurrentHashMap中還定義了三個原子操做，用於對指定位置的節點進行操做。這三種原子操做被普遍的使用在ConcurrentHashMap的get和put等方法中，

正是這些原子操做保證了ConcurrentHashMap的線程安全。

// 獲取tab數組的第i個node

static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
// 利用CAS算法設置i位置上的node節點。在CAS中，會比較內存中的值與你指定的這個值是否相等，若是相等才接受
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
// 利用volatile方法設置第i個節點的值，這個操做必定是成功的。
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
    U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}

2、ConcurrentHashMap的put方法

接下來，咱們來看下ConcurrentHashMap中最主要的put方法的實現，在put方法中調用了putVal方法，其源碼以下：

final V putVal(K key, V value, boolean onlyIfAbsent) {
    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;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable(); // table是在首次插入元素的時候初始化，lazy
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, // 若是這個位置沒有值，直接放進去，由CAS保證線程安全，不須要加鎖
                         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;
            synchronized (f) {  // 節點上鎖，這裏的節點能夠理解爲hash值相同組成的鏈表的頭節點，鎖的粒度爲頭節點。
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            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) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

從上面咱們能夠發現ConcurrentHashMap的put方法的主要流程以下：

所以，咱們能夠發現JDK8中ConcurrentHashMap的實現使用的是鎖分離思想，只是鎖住的是一個node，而鎖住Node以前的操做是基於在volatile和CAS之上無鎖而且線程安全的。