ConcurrentHashMap的源码分析

废话不多说，我们直接上代码

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // key和value不能为NULL
    if (key == null || value == null) throw new NullPointerException();
    
    // key所对应的hashcode
    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();
        // 算出数组下标，然后获取数组上对应下标的元素，如果为null，则通过cas来赋值
        // 如果赋值成功，则退出自旋，否则是因为数组上当前位置已经被其他线程赋值了，
        // 所以失败，所以进入下一次循环后就不会再符合这个判断了
        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
        }
        // 如果数组当前位置的元素的hash值等于MOVED，表示正在进行扩容，当前线程也进行扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 对数组当前位置的元素进行加锁
            synchronized (f) {
                // 加锁后检查一下tab[i]上的元素是否发生了变化，如果发生了变化则直接进入下一次循环
                // 如果没有发生变化，则开始插入新key,value
                if (tabAt(tab, i) == f) {
                    // 如果tab[i]的hashcode是大于等于0的，那么就将元素插入到链表尾部
                    if (fh >= 0) {
                        binCount = 1; // binCount表示当前链表上节点的个数，不包括新节点
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 遍历链表的过程中比较key是否存在一样的
                            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;
                            }
                        }
                    }
                    // 如果tab[i]是TreeBin类型，表示tab[i]位置是一颗红黑树
                    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了，那么就要进行树化
                // 比如binCount为8，那么此时tab[i]上的链表长度为9，因为包括了新元素
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                // 存在key相同的元素
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

// 初始化数组
// 一个线程在put时如果发现tab是空的，则需要进行初始化
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // sizeCtl默认等于0，如果为-1表示有其他线程正在进行初始化，本线程不竞争CPU
        // yield表示放弃CPU，线程重新进入就绪状态，重新竞争CPU，如果竞争不到就等，如果竞争到了又继续循环
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // 通过cas将sizeCtl改为-1，如果改成功了则进行后续操作
        // 如果没有成功，则表示有其他线程在进行初始化或已经把数组初始化好了
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                // 当前线程将sizeCtl改为-1后，再一次判断数组是否为空
                // 会不会存在一个线程进入到此处之后，数组不为空了？
                if ((tab = table) == null || tab.length == 0) {
                    // 如果在构造ConcurrentHashMap时指定了数组初始容量，那么sizeCtl就为初始化容量
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    // 如果n为16，那么就是16-4=12
                    // sc = 3*n/4 = 0.75n, 初始化完成后sizeCtl的数字表示扩容的阈值
                    sc = n - (n >>> 2);
                }
            } finally {
                // 此时sc为阈值
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

private final void addCount(long x, int check) {
    // 先通过CAS更新baseCount（+1）
    // 如果更新失败则通过CAS更新CELLVALUE
    // 如果仍然失败则调用fullAddCount
    
    // as是一个CounterCell数组，一个CounterCell对象表示一个计数器，
    // 多个线程在添加元素时，手写都会尝试去更新baseCount，那么只有一个线程能更新成功，另外的线程将更新失败
    // 那么其他的线程就利用一个CounterCell对象来记一下数
    CounterCell[] as; long b, s;
     
    //
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        // 某个线程更新baseCount失败了
        CounterCell a; long v; int m;
        boolean uncontended = true;
        // 如果CounterCell[]是null
        // 或者CounterCell[]不为null的情况下CounterCell[]的长度小于1也就是等于0，
        // 或者CounterCell[]长度不为0的情况下随机计算一个CounterCell[]的下标，并判断此下标位置是否为空
        // 或者CounterCell[]中的某下标位置不为null的情况下通过cas修改CounterCell中的值失败了
        // 才调用fullAddCount方法，然后返回
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        // 如果修改CELLVALUE成功了，这里的check就是binCount，这里为什么要判断小于等于1
        if (check <= 1)
            return;
        
        // 如果修改CELLVALUE成功了，则统计ConcurrentHashMap的元素个数
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        
        // 如果元素个数大于等于了阈值或-1就自旋扩容
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            // resizeStamp这个方法太难理解，反正就是返回一个数字，比如n=16,rs则=32795
            int rs = resizeStamp(n);
            // 如果sc小于0,表示已经有其他线程在进行扩容了，sc+1
            if (sc < 0) {
                // 如果全部元素已经转移完了，或者已经达到了最大并发扩容数限制则breack
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                // 如果没有，则sizeCtl加1，然后进行转移元素
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 如果sc是大于0的并且如果修改sizeCtl为一个特定的值，比如n=16, rs << RESIZE_STAMP_SHIFT) + 2= -2145714174
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                // 转移元素，转移完了之后继续进入循环中
                transfer(tab, null);
            s = sumCount();
        }
    }
}