一、前言
使用过 HashMap 的同学应该都听说过，它存在着并发安全问题，具体的并发安全问题这里我们就不做详细的阐述。
要想使用并发安全的容器，我们可以选择 HashTable、Collections.synchronizedMap、以及ConcurrentHashMap 可以实现线程安全的Map。
Hashtable也是一个线程安全的类，它是直接在操作方法上加synchronized关键字，锁住整个数组，粒度比较大，效率比较低，这个方法就不建议使用了。
我们这里就着重讲一下 ConcurrentHashMap。
二、JDK 1.7：Segment 数组 + HashEntry 数组 + 链表
ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成。Segment 继承自 ReentranLock，在 ConcurrentHashMap 里扮演锁的角色，HashEntry 则用于存储键值对数据。
一个 ConcurrentHashMap 里包含一个 Segment 数组，Segment 的结构和 HashMap 类似，是一种数组和链表结构， 一个 Segment 里包含一个 HashEntry 数组， 每个 HashEntry 是一个链表结构的元素 。Segment 中的 HashEntry 数组可以后期扩充。
//ConcurrentHashMap中真正存储数据的对象 HashEntry 的结构
static final class HashEntry<K,V> {
final int hash; //通过运算，得到的键的hash值
final K key; // 存入的键
volatile V value; //存入的值
volatile HashEntry<K,V> next; //记录下一个元素，形成单向链表
}默认的 Segement 有 16 个所以最多可以支持 16 个线程并发操作，可以在初始化时指定为其他值，初始化之后就不能再修改。
每个 Segment 守护者一个 HashEntry 数组里的元素,当对 HashEntry 数组的数据进行修改时，必须首先获得它对应的 Segment 锁。但是而在 JAVA8之后采用 CAS 无锁算法，这种乐观操作在完成前进行判断，如果符合预期结果才给予执行，对并发操作提供良好的优化。
有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。
1.初始化
（1）无参构造
//空参构造
public ConcurrentHashMap() {
//调用本类的带参构造
//DEFAULT_INITIAL_CAPACITY = 16 定义ConcurrentHashMap存放元素的容量
//DEFAULT_LOAD_FACTOR = 0.75f 负载因子，在判断扩容的时候用到，默认是0.75
//DEFAULT_CONCURRENCY_LEVEL = 16 定义ConcurrentHashMap中Segment[]的大小，也就是分段锁的个数
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
（2）有参构造
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
int sshift = 0;
int ssize = 1;
//ssize。计算Segment[]的大小，保证是2的幂次方数
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
//这两个值用于后面计算Segment[]的角标
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
//计算每个Segment中存储元素的个数
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
//最小Segment中存储元素的个数为2
int cap = MIN_SEGMENT_TABLE_CAPACITY;
矫正每个Segment中存储元素的个数，保证是2的幂次方，最小为2
while (cap < c)
cap <<= 1;
//创建一个Segment对象，作为其他Segment对象的模板
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
//利用Unsafe类，将创建的Segment对象存入0角标位置。 SBASE是Segment数组在内存中的偏移量
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
加载因子和初始容量这里就不细说了，我们主要来看一下 concurrencyLevel。
concurrencyLevel
并发度可以理解为程序运行时能够同时更新 ConccurentHashMap 且不产生锁竞争的最大线程数，实际上就是 ConcurrentHashMap 中的分段锁个数，即Segment[]的数组长度。ConcurrentHashMap默认的并发度为16，但用户也可以在构造函数中设置并发度。当用户设置并发度时，ConcurrentHashMap会使用大于等于该值的最小2幂指数作为实际并发度（假如用户设置并发度为17，实际并发度则为32）。运行时通过将key的高n位（n = 32 – segmentShift）和并发度减1（segmentMask）做位与运算定位到所在的Segment。segmentShift与segmentMask都是在构造过程中根据concurrency level被相应的计算出来。
如果并发度设置的过小，会带来严重的锁竞争问题；如果并发度设置的过大，原本位于同一个Segment内的访问会扩散到不同的Segment中，CPU cache命中率会下降，从而引起程序性能下降。
ConcurrentHashMap 中保存了一个 默认长度为16的 Segment[] ，每个 Segment 元素中保存了一个 默认长度为 2 的 HashEntry[] ，HashEntry[] 中每个节点代表一个链表的头节点。 我们添加的元素，是存入对应的 Segment 中的 HashEntry[] 中。所以 ConcurrentHashMap 中默认元素的长度是 32 个。
2.put流程
/* 一： 先调用 ConcurrentHashMap 中的 put 方法*/
public V put(K key, V value) {
Segment<K,V> s;
// 不允许空值空键
if (value == null)
throw new NullPointerException();
//基于key，计算hash值
int hash = hash(key);
//因为一个键要计算两个数组的索引，为了避免冲突，这里取高位计算Segment[]的索引
int j = (hash >>> segmentShift) & segmentMask;
//判断该索引位的Segment对象是否创建，没有就创建
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
//调用Segmetn的put方法实现元素添加
return s.put(key, hash, value, false);
}
/* 二： ConcurrentHashMap的ensureSegment方法*/
//创建对应索引位的Segment对象，并返回
private Segment<K,V> ensureSegment(int k) {
final Segment<K,V>[] ss = this.segments;
long u = (k << SSHIFT) + SBASE; // raw offset
Segment<K,V> seg;
//获取，如果为null，即创建
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
//以0角标位的Segment为模板
Segment<K,V> proto = ss[0]; // use segment 0 as prototype
int cap = proto.table.length;
float lf = proto.loadFactor;
int threshold = (int)(cap * lf);
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
//获取，如果为null，即创建
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck
//创建
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
//自旋方式，将创建的Segment对象放到Segment[]中，确保线程安全
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) {
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
//返回
return seg;
}
/* 三： Segment的put方法 */
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//尝试获取锁，获取成功，node为null，代码向下执行
//如果有其他线程占据锁对象，那么去做别的事情，而不是一直等待，提升效率
//scanAndLockForPut 稍后分析
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
//取hash的低位，计算HashEntry[]的索引
int index = (tab.length - 1) & hash;
//获取索引位的元素对象
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
//获取的元素对象不为空
if (e != null) {
K k;
//如果是重复元素，覆盖原值
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
//如果不是重复元素，获取链表的下一个元素，继续循环遍历链表
e = e.next;
}
else { //如果获取到的元素为空
//当前添加的键值对的HashEntry对象已经创建
if (node != null)
node.setNext(first); //头插法关联即可
else
//创建当前添加的键值对的HashEntry对象
node = new HashEntry<K,V>(hash, key, value, first);
//添加的元素数量递增
int c = count + 1;
//判断是否需要扩容
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//需要扩容
rehash(node);
else
//不需要扩容
//将当前添加的元素对象，存入数组角标位，完成头插法添加元素
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
//释放锁
unlock();
}
return oldValue;
}
/* 四：Segment的scanAndLockForPut方法
* 该方法在线程没有获取到锁的情况下，去完成HashEntry对象的创建，提升效率
*/
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
//获取头部元素
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null；
int retries = -1; // negative while locating node
while (!tryLock()) {
//获取锁失败
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
//没有下一个节点，并且也不是重复元素，创建HashEntry对象，不再遍历
if (e == null) {
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
else if (key.equals(e.key))
//重复元素，不创建HashEntry对象，不再遍历
retries = 0;
else
//继续遍历下一个节点
e = e.next;
}
else if (++retries > MAX_SCAN_RETRIES) {
//如果尝试获取锁的次数过多，直接阻塞
//MAX_SCAN_RETRIES会根据可用cpu核数来确定
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
//如果期间有别的线程获取锁，重新遍历
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
从上面的源码中可以看出：
put 时首先会定位到Segment，之后尝试 获取 Segment 的锁 ，如果获取失败肯定存在其它线程竞争，如何获得锁？
- 自旋获取锁
- 重试次数达到最大重试次数后，改为阻塞锁获取
获得锁之后在 Segement 中进行插入操作， 插入操作 需要经历两个过程：
- 判断是否需要扩容。
- 定位添加元素的位置，放入到 HashEntry 数组。
之后 解除之前获得的锁 。
3.rehash流程
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
//两倍容量
int newCapacity = oldCapacity << 1;
threshold = (int)(newCapacity * loadFactor);
//基于新容量，创建HashEntry数组
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
//实现数据迁移
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
if (e != null) {
HashEntry<K,V> next = e.next;
int idx = e.hash & sizeMask;
if (next == null) // Single node on list
//原位置只有一个元素，直接放到新数组即可
newTable[idx] = e;
else { // 重用一个槽位中的一段连续序列，这一段序列在新槽位中的下标相同
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
newTable[lastIdx] = lastRun;
// Clone remaining nodes
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
//这里旧的HashEntry不会放到新数组
//而是基于原来的数据创建了一个新的HashEntry对象，放入新数组
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
//采用头插法，将新元素加入到数组中
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
相对于HashMap的 resize，ConcurrentHashMap 的 rehash 原理类似，但是 Doug Lea 为rehash做了一定的优化，避免让所有的节点都进行复制操作：由于扩容是基于 2 的幂指来操作，假设扩容前某 HashEntry 对应到 Segment 中数组的index为i，数组的容量为 capacity，那么扩容后该 HashEntry 对应到新数组中的 index 只可能为 i 或者 i+capacity，因此大多数 HashEntry 节点在扩容前后 index 可以保持不变。
基于上述原理，可以对已有链表进行遍历，对于老的 oldTable 中的每个 HashEntry，从头结点开始遍历，找到一段连续的节点链表，这个链表满足以下要求：
- 链表中的节点在新的 segment 数组中的位置相同
- 链表位于 segment 数组末尾
之后直接将这串链表接到新数组上去，不用新 new 节点。
最后将其他节点放入到新的数组中，基于原有节点 new 一个新的节点。
4.get流程
/* get 操作直接调用给Segment的 get 方法*/
V get(Object key, int hash) {
if (count != 0) { // read-volatile 当前桶的数据个数是否为0
HashEntry e = getFirst(hash); 得到头节点
while (e != null) {
if (e.hash == hash && key.equals(e.key)) {
V v = e.value;
if (v != null)
return v;
return readValueUnderLock(e); // recheck
}
e = e.next;
}
}
return null;
}
从图上的源码可以看出 get 的一个流程：
- 计算 hash 值，找到 segment 数组中的具体位置，或我们前面用的“槽”
- 槽中也是一个数组，根据 hash 找到数组中具体的位置
- 到这里是链表了，顺着链表进行查找即可
get操作不需要锁。除非读到的值是空的才会加锁重读。
三、JDK 1.8：Node 数组 + 链表 / 红黑树
它摒弃了 JDK7 中 Segment 的概念，Segment 有什么缺陷？每次通过 hash 确认位置时需要 2 次才能定位到当前 key 应该落在哪个槽：
- 通过 hash 值和 段数组长度-1 进行位运算确认当前 key 属于哪个段，即确认其在 segments 数组的位置。
- 再次通过 hash 值和 table 数组（即 ConcurrentHashMap 底层存储数据的数组）长度 - 1进行位运算确认其 HashEntry 桶位置。
于是 在JDK8 中启用了一种全新的方式实现,利用 CAS 算法。它沿用了与它同时期的 HashMap 版本的思想，底层依然由 散列表+红黑树，但是为了做到并发，又增加了很多辅助的类，例如 TreeBin，Traverser 等对象内部类。
1.初始化
（1）无参构造
public ConcurrentHashMap() {
}没有维护任何变量的操作，如果调用该方法，数组长度默认是16。
（2）有参构造
// 参数只有一个初始容量，ConcurrentHashMap会基于这个值计算一个比这个值大的2的幂次方数作为初始容量
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
// 调用下面这个有参构造，并发度设置为 1
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
// 计算一个大于或者等于给定的容量值，该值是2的幂次方数作为初始容量
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
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}2.put流程
public V put(K key, V value) {
return putVal(key, value, false);
}
/* put 调用 putVal 方法*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
//如果有空值或者空键，直接抛异常
if (key == null || value == null) throw new NullPointerException();
//基于key计算hash值，并进行一定的扰动
int hash = spread(key.hashCode());
//记录某个桶上元素的个数，如果超过8个，会转成红黑树
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();
//如果hash计算得到的桶位置没有元素，利用cas将元素添加
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//cas+自旋（和外侧的for构成自旋循环），保证元素添加安全
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//如果hash计算得到的桶位置元素的hash值为MOVED，证明正在扩容，那么协助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
//hash计算的桶位置元素不为空，且当前没有处于扩容操作，进行元素添加
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, null);
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;
}
}
}
}
if (binCount != 0) {
//链表长度大于/等于8，将链表转成红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
//如果是重复键，直接将旧值返回
if (oldVal != null)
return oldVal;
break;
}
}
}
//添加的是新元素，维护集合长度，并判断是否要进行扩容操作
addCount(1L, binCount);
return null;
}
/* 初始化底层数组 */
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
//cas+自旋，保证线程安全，对数组进行初始化操作
while ((tab = table) == null || tab.length == 0) {
//如果sizeCtl的值（-1）小于0，说明此时正在初始化， 让出cpu
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
//cas修改sizeCtl的值为-1，修改成功，进行数组初始化，失败，继续自旋
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
//sizeCtl为0，取默认长度16，否则去sizeCtl的值
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
//基于初始长度，构建数组对象
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
//计算扩容阈值，并赋值给sc
sc = n - (n >>> 2);
}
} finally {
//将扩容阈值，赋值给sizeCtl
sizeCtl = sc;
}
break;
}
}
return tab;
}
通过以上源码，我们可以看到，当需要添加元素时，会针对当前元素所对应的桶位进行加锁操作，这样一方面保证元素添加时，多线程的安全，同时对某个桶位加锁不会影响其他桶位的操作，进一步提升多线程的并发效率。
- 判断Node[] 数组是否初始化，没有则进行初始化操作
- 通过 hash 定位数组的索引坐标，是否有 Node 节点，如果没有则使用 CAS 进行添加（链表的头节点），添加失败则进入下次循环。
- 检查到内部正在扩容，就帮助它一块扩容。
- 如果 f != null ，则使用 synchronized 锁住 f 元素（链表/红黑二叉树的头元素）
- 如果是 Node （链表结构）则执行链表的添加操作
- 如果是 TreeBin （树形结构）则执行树添加操作。
- 判断链表长度已经达到临界值 8 ，当然这个 8 是默认值，允许自定义，当节点数超过这个值就需要把链表转换为树结构。
3.get流程
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
// 检查 table 是否存在，hashCode 所在的索引是有为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// 按照树的方式遍历 Node 查找
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// 按照链表的方式遍历 Node 查找
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
从源码中可以得出 get 的一个流程如下：
- 计算 Hash 值，并由此值找到对应的槽位；
- 如果数组是空的或者该位置为 null，那么直接返回 null 就可以了；
- 如果该位置处的节点刚好就是我们需要的，直接返回该节点的值；
- 如果该位置节点是红黑树或者正在扩容，就用 find 方法继续查找；
- 否则那就是链表，就进行遍历链表查找
四、总结
1.JDK 1.7
在 JDK7 中 ConcurrentHashMap 保证高并发的三个方面：
- 用分段锁实现降低锁粒度，提升并发度
- 用HashEntery对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的需求
- 通过对同一个 volatile 变量的写/读访问，协调不同线程间读/写操作的内存可见性
2.JDK 1.8
在 JDK8 中，Java8 中的 ConcurrentHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由 Java7 中的 Segment 数组 + HashEntry 数组 + 链表 进化成了 Node 数组 + 链表 / 红黑树 ，Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时会转化成红黑树，在冲突小于一定数量时又退回链表。
JDK1.8为什么使用内置锁synchronized来代替重入锁ReentrantLock 有一下几点原因：
- 因为粒度降低了，在相对而言的低粒度加锁方式，synchronized并不比ReentrantLock差，在粗粒度加锁中ReentrantLock可能通过Condition来控制各个低粒度的边界，更加的灵活，而在低粒度中，Condition的优势就没有了。
- JVM的开发团队从来都没有放弃synchronized，而且基于JVM的synchronized优化空间更大，使用内嵌的关键字比使用API更加自然。
- 在大量的数据操作下，对于JVM的内存压力，基于API的ReentrantLock会开销更多的内存，虽然不是瓶颈，但是也是一个选择依据。
2327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
