Java併發Concurrent包——ConcurrentHashMap原理分析

ConcurrentHashMap 和 HashMap 的底層實現都是 數組+鏈表或紅黑樹 構成的。
HashMap 的源碼分析見：Java集合框架——HashMap源碼分析

ConcurrentHashMap 相比 HashMap 支持多線程下的操作。
而與 HashTable 相比，雖然 HashTable 也是線程安全的，但是其大量使用的是 synchronized 關鍵字，鎖的粒度比較大，導致多線程下效率受影響。
ConcurrentHashMap 加鎖粒度在數組中的每個桶，所以在多線程環境下，並不影響其他線程的操作。

屬性

    // 最大容量，2的30次方
    private static final int MAXIMUM_CAPACITY = 1 << 30;
    // 默認的初始容量爲16，其必須爲2的整數次方
    private static final int DEFAULT_CAPACITY = 16;
    // 最大數組容量，最大整數減8（這個值和ArrayList的底層數組原理一致）
    static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    // 默認併發級別（未使用但爲與該類以前版本兼容）
    private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
    // 默認的加載因子
    private static final float LOAD_FACTOR = 0.75f;
    // Java8中鏈表轉樹的閾值8
    static final int TREEIFY_THRESHOLD = 8;
    // Java8中樹轉鏈表的閾值6
    static final int UNTREEIFY_THRESHOLD = 6;
    // Java8中轉樹時數組容量最小值
    // 當桶數量太小時，而一個桶中超過8個，此時應該先數組擴容而不是轉樹
    // 爲了避免轉樹還是擴容的衝突，這個值不能小於4*TREEIFY_THRESHOLD
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 每次轉移的最小值
    private static final int MIN_TRANSFER_STRIDE = 16;
    // 生成sizeCtl所使用的bit位數
    private static int RESIZE_STAMP_BITS = 16;
    // 進行擴容所允許的最大線程數
    private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
    // 記錄sizeCtl中的大小所需要進行的偏移位數
    private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
    // 一系列的標識
    static final int MOVED     = -1; // hash for forwarding nodes
    static final int TREEBIN   = -2; // hash for roots of trees
    static final int RESERVED  = -3; // hash for transient reservations
    static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
    // 獲取可用的CPU個數
    static final int NCPU = Runtime.getRuntime().availableProcessors();
    // 進行序列化的屬性
    private static final ObjectStreamField[] serialPersistentFields = {
        new ObjectStreamField("segments", Segment[].class),
        new ObjectStreamField("segmentMask", Integer.TYPE),
        new ObjectStreamField("segmentShift", Integer.TYPE)
    };

    // 節點數組
    transient volatile Node<K,V>[] table;
    // 擴容時的新數組
    private transient volatile Node<K,V>[] nextTable;
    // 基本計數
    private transient volatile long baseCount;
    // 對錶初始化和擴容控制
    // 當爲負數時：-1代表正在初始化，-N代表有N-1個線程正在進行擴容
    // 當爲0時：代表當時的table還沒有被初始化
    // 當爲正數時：表示初始化或者下一次進行擴容的大小
    private transient volatile int sizeCtl;
    // 擴容下另一個表的索引
    private transient volatile int transferIndex;
    // 自旋鎖
    private transient volatile int cellsBusy;
    // counterCell表
    private transient volatile CounterCell[] counterCells;
    // 視圖
    private transient KeySetView<K,V> keySet;
    private transient ValuesView<K,V> values;
    private transient EntrySetView<K,V> entrySet;

    // Unsafe實例，主要用於反射獲取對象相應的字段。
    private static final sun.misc.Unsafe U;
    private static final long SIZECTL;
    private static final long TRANSFERINDEX;
    private static final long BASECOUNT;
    private static final long CELLSBUSY;
    private static final long CELLVALUE;
    private static final long ABASE;
    private static final int ASHIFT;

    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);
        }
    }

主要構造函數

創建一個帶有指定初始容量、加載因子和併發級別的新的空映射。

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

會根據輸入的 initialCapacity 的大小來確定一個最小的且大於等於 initialCapacity 大小的 2 的 n 次冪。構造函數中的 concurrencyLevel 參數已經在JDK8 中的意義發生了很大的變化，其並不代表所允許的併發數，其只是用來確定 sizeCtl 大小，在 JDK8 中的併發控制都是針對具體的桶而言，即有多少個桶就可以允許多少個併發數。

主要方法

putVal

    final V putVal(K key, V value, boolean onlyIfAbsent) {
        // 鍵或值爲null，拋空指針異常
        if (key == null || value == null) throw new NullPointerException();
        // 獲取hash值，spread的算法下面說
        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)
                // 數組爲null或者長度爲0，初始化數組
                tab = initTable();
            // 如果數組不爲空，而且hash值對應存放的下標的桶爲空
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                // 使用CAS將該節點存放與該下標的空桶中（空桶中添加數據不用加鎖）
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   
            }
            else if ((fh = f.hash) == MOVED)
                // 如果該hash值爲-1，節點需要轉移，在擴容的過程中
                tab = helpTransfer(tab, f);
            else {
                // 正常情況下
                V oldVal = null;
                // 對桶中的第一個節點加同步鎖
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        // 節點的hash值大於0
                        if (fh >= 0) {
                            binCount = 1;
                            // 無限循環，對鏈表進行遍歷查找
                            // 從第一個節點開始遍歷，一直到最後一個節點，每走一個節點binCount加1
                            // 如果中間找到相等的就做值替換，找不到就在最後加上新節點
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    // 節點的hash相等並且key也相等，做值替換即可
                                    // 保存舊值
                                    oldVal = e.val;
                                    // onlyIfAbsent一般爲false，這裏替換爲新值
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                // 當前節點
                                Node<K,V> pred = e;
                                // 如果當前節點的下一個節點爲null，說明已經是最後節點，可以再其後添加新節點
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        // 如果f是紅黑樹節點類型，將節點存入紅黑樹中
                        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;
                            }
                        }
                    }
                }
                // binCount不爲0說明發生了更新或結構變化
                if (binCount != 0) {
                    // 如果binCount大於等於閾值8，說明新加節點後，肯定超過閾值8了，那麼就要轉化爲紅黑樹
                    if (binCount >= TREEIFY_THRESHOLD)
                        // 對數組中下標i處的單鏈錶轉爲紅黑樹
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        // 統計size，並且檢查是否需要擴容
        addCount(1L, binCount);
        return null;
    }

下面分別看上邊用到的重要方法

initTable

    private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            // sizeCtl小於0，說明其他線程正在進行初始化或者擴容操作，則當前線程必須讓步等待
            if ((sc = sizeCtl) < 0)
                Thread.yield();
            // 比較SIZECTL和sizeCtl的值是否相等，如果相等則用-1替換
            // -1表示正在初始化，即當前線程正在初始化
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        // sc大於0的話，就取sc的值作爲容量
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        // 生成節點數組
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        // 數組容量的0.75倍
                        sc = n - (n >>> 2);
                    }
                } finally {
                    // 設置sizeCtl的值（數組容量的0.75倍）
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

tabAt

返回 table 數組中下標爲i的結點。

    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);
    }

casTabAt

比較 table 數組下標爲 i 的節點是否爲 c ，若爲 c，則用 v 交換。否則，不進行交換操作。

    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);
    }

helpTransfer

helpTransfer 方法爲協助擴容方法，當調用該方法的時候，nextTable 一定已經創建了，所以該方法主要則是進行復制工作。
其中 ForwardingNode 是一個特殊的 Node 節點，hash 值爲 -1，其中存儲 nextTable 的引用。只有 table 發生擴容的時候，ForwardingNode 纔會發揮作用，作爲一個佔位符放在 table 中表示當前節點爲 null 或則已經被移動。

    final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
        Node<K,V>[] nextTab; int sc;
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
            int rs = resizeStamp(tab.length);
            while (nextTab == nextTable && table == tab &&
                   (sc = sizeCtl) < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                    transfer(tab, nextTab);
                    break;
                }
            }
            return nextTab;
        }
        return table;
    }

addCount

addCount 方法主要是給 baseCount 值加 1 的操作，同時判斷是否要進行擴容。