ConcurrentHashMap源码详解

---

JAVA后端开发知识总结（持续更新…）

---

ConcurrentHashMap源码详解

---

---

一、1.7和1.8的ConcurrentHashMap异同

1. 都不允许key和value为null，否则会抛出异常。
2. 和HashMap的功能基本一致，重点解决了HashMap多线程的不安全问题。
3. 安全并发实现原理：

• JDK1.7中的ConcurrentHashMap

  JDK1.7中的ConcurrentHashMap采用了数组+Segment+分段锁的基本设计理念，简单理解就是切分成多个（默认是16）Segment（分段锁）块。Segment继承自ReentrantLock锁，所以并发操作时每个Segment互不影响，理论上是可以支持CurrencyLevel(Segment数组大小)的并发度的。对于每段Segment，保证只有一个线程能够访问，但是与其它段的线程互不冲突，实现了真正的并发访问。

• JDK1.8中的ConcurrentHashMap

  JDK1.8中将Segment块换成了Node，每个Node采用循环CAS + synchronized实现线程安全，即每个Node都有自己的并发度。

4. 数据结构：

• JDK1.7

  JDK1.7是Segment数组 + HashEntry<K, V>链表，其中HashEntry<K, V>中的value和next属性都由volatile修饰，保证了多线程之间的可见性。

// 底层是 Segment[] 数组
final Segment<K,V>[] segments;

// Segment 继承自 ReentrantLock，内部是 HashEntry<K,V>[]
static final class Segment<K,V> extends ReentrantLock implements Serializable {
   
	// 真正存放数据的桶
	transient volatile HashEntry<K,V>[] table;
	transient int threshold;
	...
}

// HashEntry<K,V>
static final class HashEntry<K,V>{
   
	final int hash;
	final K key;
	// 保证多线程的可见性
	volatile V value;
	volatile HashEntry<K,V> next;
}

• JDK1.8

  JDK1.8的数据结构十分接近HashMap，也是数组+链表+ 红黑树的形式（对于HashMap，可以详细看看这篇文章）。同样的，其Node节点的val和next属性都有加volatile保证多线程的可见性。

图片来源：《深入理解HashMap和CurrentHashMap》

// ConcurrentHashMap的底层是一个 Node[] 数组
transient volatile Node<K,V>[] table;

// Node节点
static class Node<K,V> implements Map.Entry<K,V> {
   
        final int hash;
        final K key;
        // 保证多线程的可见性
        volatile V val;
        volatile Node<K,V> next;
}

// 红黑树节点
static final class TreeNode<K,V> extends Node<K,V> {
   
        TreeNode<K,V> parent;  
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    
        boolean red;
}        

5. 出现hash冲突时，1.7中采用采用链表进行存储，而1.8中和HashMap相似，先链表存储，达到阈值再转换为红黑树来优化查询。也因此，链表查询复杂度在1.7中为O(N)，而1.8中红黑树优化为O(logN))。
6. 1.8的锁粒度变小，从对每个Segment段加锁，变为对每个Node节点加锁。
7. 对于1.7中的ConcurrentHashMap，进行哈希操作有两步，效率偏低，因为此时需要先找出Segment段，再在其中寻找对应的桶。

二、1.8中的主要方法源码解析

2.1 重要成员变量

// ConcurrentHashMap 的底层结构，默认为 null，懒加载
// 初始化发生在第一次 put() 时，默认大小为 16
transient volatile Node<K,V>[] table;

// 默认为 null，扩容时新生成的数组，通常其大小为原数组的两倍
private transient volatile Node<K,V>[] nextTable;

// 用于数组初始化与扩容控制
private transient volatile int sizeCtl;

• sizeCtl

• 当前未初始化时，sizeCtl = 0表示未指定初始容量；sizeCtl > 0表示由指定的初始容量计算最近的2的幂次方来作为初始容量值。
• 在初始化的过程中，sizeCtl = -1表示table正在初始化；sizeCtl = -N表示有 N-1 个线程正在进行扩容操作。
• 初始化完成，其值为 table.length * 0.75，表示将扩容阈值调为table容量大小的0.75倍。

2.2 put()

// 当设置为 false 时表示这个 value 一定会设置
public V put(K key, V value) {
   
        return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
   
		// 拒绝 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;
            // 这是 Map 第一次被使用，需要进行初始化
            if (tab == null || (n = tab.length) == 0)
                // CAS 进行数组初始化
                tab = initTable();
            // 当前 key 通过 (n-1) & hash 定位出的位置如果为空，则表示当前位置可以直接写入数据
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
   
            	// 利用 CAS 尝试写入，失败则自旋保证成功
            	// 此时采用乐观锁，不需要加互斥锁
                if (casTabAt(tab, i, null, new Node