ConcurrentHashMap 原理和源码分析(二)详解编程语言

上一篇文章《ConcurrentHashMap 原理和源码分析(一)》 介绍了ConcurrentHashMap基础内部结构、还有原理；

本篇主要分析源代码，从几个主要的方法看ConcurrentHashMap内部是怎么实现的，以及ConcurrentHashMap的扩容机制和遍历机制。

其中上篇中介绍的一个重要的变量 sizeCtl 在这里会不断出现，为了方便理解，这里再把它拉过来下：

sizeCtl == 0 时候，默认情况
sizeCtl == -1 时候，说明table正在初始化
sizeCtl > 0 时候，说明接下来初始化要的初始化容量或者是扩容成功后threadshold的值
sizeCtl < 0 时候，说明正在扩容，高16位是数据校验位，低16位表示 n – 1个线程在参与扩容线程数

基本操作

构造函数和初始化

默认构造函数，什么事情都不做，可见ConcurrentHashMap是懒加载的模式，等到需要的时候再初始化；

public ConcurrentHashMap() {
    
} 

再看一个比较复杂的构造函数

// loadFactor 是加载因子，达到扩容的临界值 = 容量 * loadFactor  
// concurrencyLevel 表示支持多少个线程并发级别，支持多线程访问的单位就是Hash桶， 
// 所以 concurrencyLevel 等于最小的桶数量（最小容量） 
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 
        // 这里跟hashMap的初始化一样，为了避免产生一次不必要的扩容 
        // 把initialCapacity当作临界值，重新算capacity 
        long size = (long)(1.0 + (long)initialCapacity / loadFactor); 
        int cap = (size >= (long)MAXIMUM_CAPACITY) ? 
            MAXIMUM_CAPACITY : tableSizeFor((int)size); 
        this.sizeCtl = cap; // sizeCtl表示准备扩容的大小 
} 

初始化 table

 private final Node<K,V>[] initTable() {
    
        Node<K,V>[] tab; int sc; 
        while ((tab = table) == null || tab.length == 0) {
    
            if ((sc = sizeCtl) < 0) // 说明正在扩容 
                Thread.yield(); // lost initialization race; just spin 
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
    
            	 // sc = sizeCtl; // 等于要初始化的容量 
            	 // sizeCtl = -1; // CAS操作，设置为正在初始化 
                try {
    
                    if ((tab = table) == null || tab.length == 0) {
    
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY; 
                        @SuppressWarnings("unchecked") 
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; 
                        table = tab = nt; 
                        // 初始化或者扩容成功后，sizeCtl变成threshold 
                        // n - n /4 = n * 0.75，实际上没用上loadFactor 
                        sc = n - (n >>> 2); 
                    } 
                } finally {
    
                    sizeCtl = sc; // 初始化完毕，将sizeCtl设置为threshold 
                } 
                break; 
            } 
        } 
        return tab; 
    } 

这里初始化操作中就使用CAS操作避免加锁的情况，在ConcurrentHashMap可以大量看到这种模式:

无限循环 + CAS

for ( ; ; ) { // 无限循环
int current = get();
int next = current + 1;
if (compareAndSet(current, next)) //CAS操作
return next;
}

putVal

增加或者修改一个节点

// onlyIfAbsent表示如果存在这个节点，是否修改 
 final V putVal(K key, V value, boolean onlyIfAbsent) {
    
 	// 可见，ConcurrentHashMap不支持null的key或value 
        if (key == null || value == null) throw new NullPointerException(); 
        int hash = spread(key.hashCode()); 
        int binCount = 0;// 桶里面节点的数量，用来决定是否树化 
        for (Node<K,V>[] tab = table;;) {
   // 无限循环 + CAS 
            Node<K,V> f; int n, i, fh; 
            if (tab == null || (n = tab.length) == 0)// 若未初始化 
                tab = initTable();// 初始化table 
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
   // 若CAS找到的是空的hash桶，直接CAS添加节点 
                if (casTabAt(tab, i, null, 
                             new Node<K,V>(hash, key, value, null))) 
                    break; // 当hash桶为空，直接CAS添加，不用加锁 
            } 
            else if ((fh = f.hash) == MOVED)// 碰到ForwardingNode，说明table在扩容 
                tab = helpTransfer(tab, f);// 加入扩容 
            else {
   // hash桶不为空 
                V oldVal = null; 
                synchronized (f) {
   // 对hash桶的首节点加锁 
                    if (tabAt(tab, i) == f) {
    
                        if (fh >= 0) {
   // hash > 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)))) {
   // 存在对应的key 
                                    oldVal = e.val; 
                                    if (!onlyIfAbsent) // 允许修改 
                                        e.val = value; 
                                    break; 
                                } 
                                Node<K,V> pred = e; 
                                if ((e = e.next) == null) {
   // 不存在对应的key 
                                    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) {
    
                                // 存在这个key 
                                oldVal = p.val; 
                                if (!onlyIfAbsent) 
                                    p.val = value; 
                            } 
                        } 
                        else if (f instanceof ReservationNode) 
                            throw new IllegalStateException("Recursive update"); 
                    } 
                } 
                if (binCount != 0) {
    
                    if (binCount >= TREEIFY_THRESHOLD)// 超过树化数量 8 
                        treeifyBin(tab, i);// 链表转化为红黑树 
                    if (oldVal != null) 
                        return oldVal; 
                    break; 
                } 
            } 
        } 
        addCount(1L, binCount);  // 新增一个节点数量 
        return null; 
    } 

其实添加节点的流程也很清晰了：

1. 找到对应的hash桶
2. hash桶为空，则CAS添加节点
3. hash桶是ForwardingNode，加入帮助扩容
4. hash桶不为空，锁住hash桶，根据链表、红黑树插入或修改节点
5. 插入完成后，树化、增加节点数量

这个操作流程在修改、删除基本一样，在对节点进行操作的时候需要通过互斥锁保证线程安全，但只需要锁住对应的hash桶。

remove

删除一个节点

//删除节点 
public V remove(Object key) {
    
        return replaceNode(key, null, null); 
} 
 
// 替换节点 
// table[key].val等于期望值cv或cv等于null，更新为value 
// 如果value为null，删除该节点 
final V replaceNode(Object key, V value, Object cv) {
    
        int hash = spread(key.hashCode()); 
        for (Node<K,V>[] tab = table;;) {
    
            Node<K,V> f; int n, i, fh; 
            if (tab == null || (n = tab.length) == 0 || 
                (f = tabAt(tab, i = (n - 1) & hash)) == null) // 找到hash桶为null 
                break; 
            else if ((fh = f.hash) == MOVED)// 碰到ForwardingNode，说明table在扩容 
                tab = helpTransfer(tab, f);// 加入帮助扩容 
            else {
    
                V oldVal = null; 
                boolean validated = false; 
                synchronized (f) {
   // 锁住hash桶 
                    if (tabAt(tab, i) == f) {
    
                        if (fh >= 0) {
    
                            validated = true; 
                            for (Node<K,V> e = f, pred = null;;) {
    
                                K ek; 
                                if (e.hash == hash && 
                                    ((ek = e.key) == key || 
                                     (ek != null && key.equals(ek)))) {
    
                                    V ev = e.val; 
                                    if (cv == null || cv == ev || 
                                        (ev != null && cv.equals(ev))) {
   // 替换修改值 
                                        oldVal = ev; 
                                        if (value != null) 
                                            e.val = value; 
                                        else if (pred != null) 
                                            pred.next = e.next; 
                                        else 
                                            setTabAt(tab, i, e.next); 
                                    } 
                                    break; 
                                } 
                                pred = e; 
                                if ((e = e.next) == null) 
                                    break; 
                            } 
                        } 
                        else if (f instanceof TreeBin) {
   // 红黑树 
                            validated = true; 
                            TreeBin<K,V> t = (TreeBin<K,V>)f; 
                            TreeNode<K,V> r, p; 
                            if ((r = t.root) != null && 
                                (p = r.findTreeNode(hash, key, null)) != null) {
   // 同样替换修改 
                                V pv = p.val; 
                                if (cv == null || cv == pv || 
                                    (pv != null && cv.equals(pv))) {
    
                                    oldVal = pv; 
                                    if (value != null) 
                                        p.val = value; 
                                    else if (t.removeTreeNode(p)) 
                                        setTabAt(tab, i, untreeify(t.first)); 
                                } 
                            } 
                        } 
                        else if (f instanceof ReservationNode) 
                            throw new IllegalStateException("Recursive update"); 
                    } 
                } 
                if (validated) {
    
                    if (oldVal != null) {
    
                        if (value == null) 
                            addCount(-1L, -1);// 将节点数量-1 
                        return oldVal; 
                    } 
                    break; 
                } 
            } 
        } 
        return null; 
} 

上面replaceNode的流程跟putVal的流程基本上是一样：

1. 找到对应的hash桶
2. hash桶是ForwardingNode，加入帮助扩容
3. hash桶不为空，锁住hash桶，根据链表、红黑树修改节点
4. 增加节点数量

get

通过指定的key，获取value

    public V get(Object key) {
    
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek; 
        int h = spread(key.hashCode());// 计算hash值 
        if ((tab = table) != null && (n = tab.length) > 0 && 
            (e = tabAt(tab, (n - 1) & h)) != null) {
    
            if ((eh = e.hash) == h) {
   // e是hash桶首节点 
                if ((ek = e.key) == key || (ek != null && key.equals(ek))) 
                    return e.val;// 首节点是目标节点，直接返回 
            } 
            else if (eh < 0)// hash小于0，调用特殊节点的find() 
                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方法的流程也是很清晰的，整个流程都没有加互斥锁：

1. 找到对应的hash桶；
2. hash桶首节点是想找的目标节点，直接返回；
3. hash桶首节点的hash小于0，说明是树的首节点或者是forwardindNode，直接调用红黑树的find()，或者forwardindNode的find()；在上一篇文章有介绍过forwardindNode的find方法；
4. hash桶首节点的hash大于0，说明是普通链表，递归查找。

扩容机制

ConcurrentHashMap支持多线程协助扩容，扩容的工作分成两部分：

1. 生成一个新的table，即nextTable，容量为原来的2倍
2. 将旧的table迁移到nextTable，这部分也是众多线程能分摊的工作

这里会产生一个疑问：多个线程参与迁移工作会不会相互干扰啊？答案是不会的。

任意一个节点，假设节点所在桶序号是2，扩容之后只有两种可能，一种是呆在原来的桶2，一种是迁移到序号是（2 + 旧容量）桶中。

线程从transferIndex中分配得到一个区间的hash桶迁移任务，比如说是旧的table的 [a, b) 区间，那么这个线程工作的桶就是 [a, b) 和 [ a+ 旧capacity, b+ 旧capacity)，这样每个任务就独立了，很适合多线程工作。

tryPresize

 private final void tryPresize(int size) {
    
 		// 计算容量 
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : 
            tableSizeFor(size + (size >>> 1) + 1); 
        int sc; 
        while ((sc = sizeCtl) >= 0) {
    
        	// sizeCtl > 0，可能是threshold或准备扩容的容量 
            Node<K,V>[] tab = table; int n; 
            if (tab == null || (n = tab.length) == 0) {
    
            // table为空，需要进行初始化 
                n = (sc > c) ? sc : c;// 选择较大的容量 
                if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
    
                //修改sizeCtl为-1，表示正在初始化 
                    try {
    
                        if (table == tab) {
    
                            @SuppressWarnings("unchecked") 
                            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; 
                            table = nt; 
                            sc = n - (n >>> 2);// sc = n * 3/4; 
                        } 
                    } finally {
    
                        sizeCtl = sc;// 设置成theashold 
                    } 
                } 
            } 
            else if (c <= sc || n >= MAXIMUM_CAPACITY) 
                break; 
            else if (tab == table) {
   // 存在table，调用transfer扩容 
                int rs = resizeStamp(n); 
                if (U.compareAndSwapInt(this, SIZECTL, sc, 
                                        (rs << RESIZE_STAMP_SHIFT) + 2)) 
                    transfer(tab, null); 
            } 
        } 
    } 

transfer

线程在许多操作如put、replace、remove碰到ForwardingNode都会调用，具体来看下怎么扩容的

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    
        int n = tab.length, stride; 
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) 
            stride = MIN_TRANSFER_STRIDE; // subdivide range 
        if (nextTab == null) {
    // 初始化nextTable           
            try {
    
                @SuppressWarnings("unchecked") 
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; 
                nextTab = nt; 
            } catch (Throwable ex) {
         // try to cope with OOME 
                sizeCtl = Integer.MAX_VALUE; 
                return; 
            } 
            nextTable = nextTab; 
            transferIndex = n; 
           //transferIndex表示目前指向的最大的hash桶索引数， 
           // 它会每次分配出去stride 个数量的桶数给线程，慢慢的减少，直至为0，表示分配完成 
        } 
        int nextn = nextTab.length; 
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); 
        boolean advance = true; 
        boolean finishing = false; // to ensure sweep before committing nextTab 
        for (int i = 0, bound = 0;;) {
    
            Node<K,V> f; int fh; 
            while (advance) {
    
            	// 分配负责的任务区间 
                int nextIndex, nextBound; 
                if (--i >= bound || finishing) 
                    advance = false; 
                else if ((nextIndex = transferIndex) <= 0) {
    
                    i = -1; 
                    advance = false; 
                } 
                else if (U.compareAndSwapInt 
                         (this, TRANSFERINDEX, nextIndex, 
                          nextBound = (nextIndex > stride ? 
                                       nextIndex - stride : 0))) {
    
                    bound = nextBound; 
                    i = nextIndex - 1; 
                    advance = false; 
                } 
            } 
            if (i < 0 || i >= n || i + n >= nextn) {
    
                int sc; 
                // 扩容任务结束，最后一个线程负责修改table,nextTable,sizeCtl 
                if (finishing) {
    
                    nextTable = null; 
                    table = nextTab; 
                    sizeCtl = (n << 1) - (n >>> 1); 
                    return; 
                } 
                // 当前线程负责的任务结束，sizeCtl - 1 
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
    
                	 // resizeStamp(n) << RESIZE_STAMP_SHIFT) 获取一个校验戳,左移16位，那么低16位都位0 
                	 // sc = （高16位）校验戳 + （低16位）（线程数 + 1） 
                	 // 初始化时候 sc = resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2 
                	 // 所以只要在最后一个线程：sc - 1 - 1 == 校验戳 
                	 // 这里既判断是不是最后一个线程，又利用校验戳判断了是不是本次扩容任务  
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)  
                        return; 
                    finishing = advance = true; 
                    i = n; // recheck before commit 
                } 
            } 
            else if ((f = tabAt(tab, i)) == null)// hash桶为null，置一个ForwardingNode 
                advance = casTabAt(tab, i, null, fwd); 
            else if ((fh = f.hash) == MOVED)// 碰到ForwardingNode，说明处理过 
                advance = true;  
            else {
    
                synchronized (f) {
   // 锁住hash桶 
                    if (tabAt(tab, i) == f) {
    
                        Node<K,V> ln, hn; 
                        if (fh >= 0) {
   // hash>0，链表节点 
                            int runBit = fh & n; 
                            Node<K,V> lastRun = f; 
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
    
                                int b = p.hash & n; 
                                if (b != runBit) {
    
                                    runBit = b; 
                                    lastRun = p; 
                                } 
                            } 
                            // 这部分跟hashmap迁移一样 
                             // 根据hash & 原capacity 是否等于0, 切分成两个链表，然后分别放在新表的i和i+n位置 
                             // hash&n == 0 说明 hash的值小，处在原来的位置i 
                             // hash&n > 0 说明 hash值大，需要迁移到新的位置i+n 
                            if (runBit == 0) {
    
                                ln = lastRun; 
                                hn = null; 
                            } 
                            else {
    
                                hn = lastRun; 
                                ln = null; 
                            } 
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
    
                                int ph = p.hash; K pk = p.key; V pv = p.val; 
                                if ((ph & n) == 0) 
                                    ln = new Node<K,V>(ph, pk, pv, ln); 
                                else 
                                    hn = new Node<K,V>(ph, pk, pv, hn); 
                            } 
                            setTabAt(nextTab, i, ln); 
                            setTabAt(nextTab, i + n, hn); 
                            setTabAt(tab, i, fwd); 
                            advance = true;// 当前hash桶完成 
                        } 
                        else if (f instanceof TreeBin) {
   // 红黑树，不做具体分析 
                            TreeBin<K,V> t = (TreeBin<K,V>)f; 
                            TreeNode<K,V> lo = null, loTail = null; 
                            TreeNode<K,V> hi = null, hiTail = null; 
                            int lc = 0, hc = 0; 
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
    
                                int h = e.hash; 
                                TreeNode<K,V> p = new TreeNode<K,V> 
                                    (h, e.key, e.val, null, null); 
                                if ((h & n) == 0) {
    
                                    if ((p.prev = loTail) == null) 
                                        lo = p; 
                                    else 
                                        loTail.next = p; 
                                    loTail = p; 
                                    ++lc; 
                                } 
                                else {
    
                                    if ((p.prev = hiTail) == null) 
                                        hi = p; 
                                    else 
                                        hiTail.next = p; 
                                    hiTail = p; 
                                    ++hc; 
                                } 
                            } 
                            // 低于UNTREEIFY_THRESHOLD，由树转化为链表 
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : 
                                (hc != 0) ? new TreeBin<K,V>(lo) : t; 
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : 
                                (lc != 0) ? new TreeBin<K,V>(hi) : t; 
                            setTabAt(nextTab, i, ln); 
                            setTabAt(nextTab, i + n, hn); 
                            setTabAt(tab, i, fwd); 
                            advance = true;// 当前hash桶完成 
                        } 
                    } 
                } 
            } 
        } 
} 

1. 如果nextTable为null，则生成nextTable，容量增长一倍
2. 线程根据 transferIndex索引分配一个区间的任务
3. 迁移过程中，将旧table中的节点用ForwaringNode代替，表示已经转移到nextTable中
4. 再根据是链表、红黑树做迁移再根据是链表、红黑树做迁移
5. 迁移完成后，最后一个退出的线程要负责收尾

计数统计

跟节点计数相关的有三个变量：baseCount，CounterCell，cellsBusy

cellsBusy是一个只有0和1两个状态的volatile整数，当做一个自旋锁，0代表无锁，1代表加锁

总体的原则就是：先尝试更新baseCount，失败再利用CounterCell

1. 通过CAS尝试更新baseCount ，如果更新成功则完成，如果CAS更新失败会进入下一步；
2. 线程通过随机数ThreadLocalRandom.getProbe() & (n-1) 计算出在counterCells数组的位置，如果不为null，则CAS尝试在couterCell上直接增加数量，如果失败会进入下一步；
3. counterCells数组会进行扩容为原来的两倍，继续随机，继续添加；
4. 最后，table节点的数量 = baseCount + counterCells每个cell记录下来的节点数量

// check > 0表示要检查是否扩容，一般是true 
private final void addCount(long x, int check) {
    
    CounterCell[] as; 
    long b, s; 
    // counterCells 不为null，或者 baseCount修改失败，说明存在并发 
    if ((as = counterCells) != null || 
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
    
        CounterCell a; long v;  int m; 
        boolean uncontended = true; 
 
		// ThreadLocalRandom.getProbe() 获取一个随机数 
		// ThreadLocalRandom.getProbe()& m 获取一个小于等于m的随机数 
        if (as == null || (m = as.length - 1) < 0 || 
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||  
			// 比较a下面的值是否为a.value,是则更新为a.value+x，相当于是为了增加CounterCell的值 
            !(uncontended = 
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
    
    		// 若因为上面的操作都失败了，则进入fulladdCount 
            fullAddCount(x, uncontended); 
            return; 
        } 
        if (check <= 1) 
            return; 
        s = sumCount(); // 计算总数 
    } 
	 
    if (check >= 0) {
    // 检查是否扩容 
        Node<K,V>[] tab, nt; int n, sc; 
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null && 
               (n = tab.length) < MAXIMUM_CAPACITY) {
    
            int rs = resizeStamp(n); // 根据一个基数生成扩容的戳 
            if (sc < 0) {
    // 正在扩容或者正在初始化 
			// (sc >>> RESIZE_STAMP_SHIFT) ：sc右移16位获取校验戳，跟rs对比是否同一次扩容 
			//  sc == rs + 1：不理解? 
			//  (nt = nextTable) == null 是否扩容完成 
			//  transferIndex <= 0 transferIndex是从大到小分发的，小于0则给线程分发完了 
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || 
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null || 
                    transferIndex <= 0) 
                    break;	 
  				// 加入帮助扩容，把正在执行transfer任务的线程数加1 
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) 
                    transfer(tab, nt); // 迁移 
            } 
    		// 开始新的扩容，rs +(线程数)+1 = rs+2 
            else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) 
                transfer(tab, null); // 迁移 
            s = sumCount(); 
        } 
    } 

private final void fullAddCount(long x, boolean wasUncontended) {
    
    int h; 
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
    // ThreadLocalRandom未初始化 
        ThreadLocalRandom.localInit();      //初始化 
        h = ThreadLocalRandom.getProbe(); 
        wasUncontended = true; 
    } 
    boolean collide = false; // 是否冲突 
    for (;;) {
    
        CounterCell[] as; CounterCell a; int n; long v; 
        if ((as = counterCells) != null && (n = as.length) > 0) {
    
            if ((a = as[(n - 1) & h]) == null) {
     
            // 从counterCells随机一个CounterCell 
                if (cellsBusy == 0) {
               // Try to attach new Cell 
                    CounterCell r = new CounterCell(x); 
                    if (cellsBusy == 0 && 
                        U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
    
 	 					// 对cellsBusy加锁 
                        boolean created = false; 
                        try {
                
						// 如果找到的位置为null,将之前创建的新Cell放入数组 
                            CounterCell[] rs; int m, j; 
                            if ((rs = counterCells) != null && 
                                (m = rs.length) > 0 && 
                                rs[j = (m - 1) & h] == null) {
    
                                rs[j] = r;  
                                created = true; 
                            } 
                        } finally {
    
                            cellsBusy = 0; 
                        } 
                        if (created) 
                            break; 
                        continue;  
                    } 
                } 
                collide = false; 
            } 
    	    // 选出的CounterCell不为null 
            else if (!wasUncontended) 
                wasUncontended = true;      
    	    // 对CounterCell尝试直接增加数值 
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)) 
                break; 
			// 上面的更新都失败了，以下不是特别理解 
            else if (counterCells != as || n >= NCPU) 
                collide = false;     // 设置冲突标志位false，重新执行循环 
            else if (!collide) 
                collide = true; //  设置冲突标志，重新执行循环 
            else if (cellsBusy == 0 &&  U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
    // 加自旋锁 
                try {
    
                    if (counterCells == as) {
    
                    		// 扩容counterCells 为原来的两倍 
                        CounterCell[] rs = new CounterCell[n << 1]; 
  						//迁移数据 
                        for (int i = 0; i < n; ++i) 
                            rs[i] = as[i]; 
                        counterCells = rs;  
                    } 
                } finally {
    
                    cellsBusy = 0; //解锁 
                } 
                collide = false; 
                continue; 
            } 
            h = ThreadLocalRandom.advanceProbe(h); // 重新计算随机数 
        } 
		// CounterCell数组未初始化 
        else if (cellsBusy == 0 && counterCells == as && 
                 U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
    
            boolean init = false; 
            try {
                              // Initialize table 
                if (counterCells == as) {
    
					// 初始容量为2 
                    CounterCell[] rs = new CounterCell[2]; 
                    rs[h & 1] = new CounterCell(x); 
                    counterCells = rs; 
                    init = true; 
                } 
            } finally {
    
                cellsBusy = 0;//解锁 
            } 
            if (init) 
                break; 
        } 
		// 如果cellsBusy 被占用，尝试更新baseCount 
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x)) 
            break;                          
    } 
} 

参考：
IT虾米网
IT虾米网
IT虾米网
IT虾米网