ConcurrentHashMap并发控制源码阅读：CAS与synchronized的应用场景分析

目录

问题引出

概要

ConcurrentHashMap源码分析

结论

2024.09.13补充

---

问题引出

在JDK1.7版本中，使用Segment+分段锁来确保线程安全。

而在JDK8版本中，采用CAS+Synchronized来保证线程安全。

那么，在其具体实现中，何时采用CAS机制，何时采用Synchronized？带着这个疑问，阅读了ConcurrentHashMap的源码，最终得到解答。

---

概要

在注释部分提到，向空桶中插入首个节点会使用 CAS这种无锁化机制。除此之外其他更新操作（插入、删除和替换）都需要对桶列表的第一个节点加锁来保证线程安全。

---

ConcurrentHashMap源码分析

下面将对putVal()进行详细解析，以此理解ConcurrentHashMap如何处理并发控制。

final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh; K fk; V fv;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else if (onlyIfAbsent // check first node without acquiring lock
                     && fh == hash
                     && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                     && (fv = f.val) != null)
                return fv;
            else {
                V oldVal = null;
                synchronized (f) {
                    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);
                                    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;
                            }
                        }
                        else if (f instanceof ReservationNode)
                            throw new IllegalStateException("Recursive update");
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

1.首先，进行散列操作、参数判空等前置操作， 并获取Table（若为空，则进行初始化）。

2.接着，使用tabAt()获取目标桶，若目标桶为空，则尝试使用CAS操作进行无锁插入。其中，casTabAt()是一个原子操作，若成功插入新节点，则立刻跳出循环。

3.如果目标桶不为空或者CAS操作失败，则进行下一步判断。若桶中节点的哈希值为"Moved"，意味着此时ConcurrentHashMap正在进行扩容。在这种情况下，本线程会协助扩容，通过helpTransfer()方法帮助数据的迁移。

4.随后，需判断新插入元素是否满足快速返回的条件。如果传入的 onlyAbsent 参数为 true，并且当前桶中的第一个节点的键和值都与新插入的键值相同，则直接返回当前节点的值，避免不必要的修改操作，优化性能

5.若以上情况均不满足，就需要采用加锁的方式保证线程安全。ConcurrentHashMap将对f（即目标桶的第一个节点），通过synchronized关键字进行加锁，保证同时只有一个线程对该桶进行修改操作。

在JDK8中，ConcurrentHashMap采用链表+红黑树的方式解决哈希冲突，当数组长度大于或等于64、table数组中任意一个链表的长度大于或等于8时，会将长度大于或等于8的链表转化为红黑树。因此，需要对桶内的数据结构进行分类讨论。

若为普通链表，遍历链表查询是否已经存在相同的key。若存在且onlyIfAbsent参数为false，则对其值进行更新；否则，在链表末尾插入新节点。

若为红黑树结构，则调用树的插入方法，在此不再展开介绍。

---

结论

综上，在JDK8版本的ConcurrentHashMap中，只有当目标桶为空时会采用CAS无锁插入方式；而在处理非空桶的插入、更新或删除时，均会采用synchronized对桶内第一个节点进行加锁。

补充：ConcurrentHashMap在将链表转化为红黑树时，以及哈希表扩容时，也均是使用synchronized保证线程安全。

---

2024.09.13补充

为什么Java8之前不以更小的粒度（桶）上锁，而是以Segment为粒度呢？
因为锁的粒度越小，锁对象和锁管理的开销越大。使用 Segment 的设计是锁争用和锁开销中的一个平衡。而Java 8 通过更精细的锁机制，利用 CAS 和 synchronized 的改进，实现了更细粒度的控制，还有效提升了性能。