ConcurrentHashMap
Java7
ConcurrentHashMap是一个线程安全的map集合
多线程下的hashmap有什么问题？
- JDK1.7：死链、元素覆盖
- JDK1.8：元素覆盖
1、底层数据结构
Segment数组（每个里面是HashEntry数组 + 链表），ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。
// jdk1.7
static class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
final float loadFactor;
Segment(float lf) { this.loadFactor = lf; }
}
JDK1.8：
Node数组 + 链表 + 红黑树 ( 采用的数据结构跟 HashMap1.8 的结构一样 )，并发控制使用 synchronized 和 CAS 来操作
-
JDK1.8底层是散列表**+**红⿊树
-
ConCurrentHashMap⽀持⾼并发的访问和更新，它是线程安全的
-
检索操作不⽤加锁，get⽅法是⾮阻塞的
-
key和value都不允许为null
为什么有了Hashtable 线程安全类还要ConcurrentHashMap
Hashtable是在每个⽅法上都加上了Synchronized完成同步(相当于锁住整个hash表)，效率低下。
ConcurrentHashMap通过在部分加锁和利⽤CAS算法 + Syn来实现同步
2、常量和内部类
//默认初始化容量，这个和 HashMap中的容量是一个概念，表示的是整个 Map的容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//默认的并发级别，这个参数决定了 Segment 数组的长度
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
//最大的容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 每个Segment中table数组的最小长度为2，且必须是2的n次幂。
// 由于每个Segment是懒加载的，用的时候才会初始化
// 因此为了避免使用时立即调整大小，设定了最小容量2
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
// 用于限制Segment数量的最大值，必须是2的n次幂
static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
// 在size方法和containsValue方法，会优先采用乐观的方式不加锁，
// 直到重试次数达到2，才会对所有Segment加锁
// 这个值的设定，是为了避免无限次的重试。后边size方法会详讲怎么实现乐观机制的。
static final int RETRIES_BEFORE_LOCK = 2;
// segment掩码值，用于根据元素的hash值定位所在的 Segment 下标
final int segmentMask;
// 和 segmentMask 配合使用来定位 Segment 的数组下标
final int segmentShift;
// Segment 组成的数组，每一个 Segment 都可以看做是一个特殊的 HashMap
final Segment<K,V>[] segments;
// Segment 对象，继承自 ReentrantLock 可重入锁。
// 其内部的属性和方法和 HashMap 神似，只是多了一些拓展功能。
static final class Segment<K,V> extends ReentrantLock implements Serializable {
// 这是在 scanAndLockForPut 方法中用到的一个参数，用于计算最大重试次数
// 获取当前可用的处理器的数量，若大于1，则返回64，否则返回1。
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
//用于表示每个Segment中的 table，是一个用HashEntry组成的数组。
transient volatile HashEntry<K,V>[] table;
// Segment中的元素个数，每个Segment单独计数（下边的几个参数同样的都是单独计数）
transient int count;
// 每次 table 结构修改时，如put，remove等，此变量都会自增
transient int modCount;
// 当前Segment扩容的阈值，同HashMap计算方法一样也是容量乘以加载因子
// 需要知道的是，每个Segment都是单独处理扩容的，互相之间不会产生影响
transient int threshold;
// 加载因子
final float loadFactor;
//Segment构造函数
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
...
// put(),remove(),rehash() 方法都在此类定义
}
// HashEntry，存在于每个Segment中
// 它就类似于HashMap中的Node，用于存储键值对的具体数据和维护单向链表的关系
static final class HashEntry<K,V> {
// 每个key通过哈希运算后的结果，
// 用的是 Wang/Jenkins hash 的变种算法，此处不细讲，感兴趣的可自行查阅相关资料
final int hash;
final K key;
// value 和 next都用 volatile 修饰，用于保证内存可见性和禁止指令重排序
volatile V value;
//指向下一个节点
volatile HashEntry<K,V> next;
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
3、构造函数
// 初始化容量、负载因子、并发级别
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
// 检查参数，并发级别一定要大于0但是不能超过最大值
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// 偏移量，是为了对hash值做位移操作，计算元素所在的Segment下标，put方法详讲
int sshift = 0;
// 用于设定最终Segment数组的长度，必须是2的n次幂
int ssize = 1;
//这里就是计算 sshift 和 ssize 值的过程 (1)
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;
// Segment的掩码
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// c用于辅助计算cap的值 (2)
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
// cap 用于确定某个Segment的容量，即Segment中HashEntry数组的长度
int cap = MIN_SEGMENT_TABLE_CAPACITY;
// （3）
while (cap < c)
cap <<= 1;
// create segments and segments[0]
// 这里用 loadFactor做为加载因子，cap乘以加载因子作为扩容阈值，
// 创建长度为cap的HashEntry数组，
// 三个参数，创建一个Segment对象，保存到S0对象中。
// 后边在 ensureSegment 方法会用到S0作为原型对象去创建对应的Segment。
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
// 创建出长度为 ssize 的一个 Segment数组
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
// 把S0存到Segment数组中去。我们就可以发现，此时只是创建了一个Segment数组，
// 但是并没有把数组中的每个Segment对象创建出来
// 仅仅创建了一个Segment用来作为原型对象。
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
假设调用了默认构造，都用的是默认参数，即 initialCapacity 和 concurrencyLevel 都是16
(1)sshift和 ssize 值的计算过程为，每次循环，都会把 sshift 自增1，并且 ssize 左移一位，即乘以
直到 ssize 的值大于等于 concurrencyLevel 的值 16。
(2)c = 16 / 16 = 1 , 判断 c * 16 < 16是否为真，真的话 c 自增1，此处为false，因此 c的值为1不变。
(3) 此时，由于c为1， cap为2 ，因此判断 cap < c 为false，最终cap为2。
总结一下，以上三个步骤，最终都是为了确定以下几个关键参数的值，
- 确定 segmentShift ，这个用于后边计算hash值的偏移量，此处即为 32-4=28，
- 确定 ssize，必须是一个大于等于 concurrencyLevel 的一个2的n次幂值此处为16，segment数组大小
- 确定 cap，必须是一个大于等于2的一个2的n次幂值，每个segment的Entry数组大小
4、put()
put 方法的总体流程是：
- 通过哈希算法计算出当前 key 的 hash 值
- 通过这个 hash 值找到它所对应的 Segment 数组的下标
- 再通过 hash 值计算出它在对应 Segment 的 HashEntry数组 的下标
- 找到合适的位置插入元素
public V put(K key, V value) {
Segment<K,V> s;
// 不支持value为空
if (value == null)
throw new NullPointerException();
// 通过一个hash算法，计算出当前key对应的hash值
int hash = hash(key);
// 上边我们计算出的 segmentShift为28，因此hash值右移28位，
// 说明此时用的是hash的高4位，然后把它和掩码15进行与运算，
// 得到的值一定是一个 0000 ~ 1111 范围内的值，即 0~15
int j = (hash >>> segmentShift) & segmentMask;
// 这里是用Unsafe类的原子操作找到Segment数组中j下标的 Segment 对象
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
// 初始化j下标的Segment
// 这时不能确定是否真的为 null, 因为其它线程也发现该 segment 为 null,
// 因此在 ensureSegment 里用 cas 方式保证该 segment 安全性
s = ensureSegment(j);
// 在此Segment中添加元素
return s.put(key, hash, value, false);
}
ensureSegment: 判断 j 下标的 Segment为空后，则需要调用此方法，初始化一个 Segment 对象 以确保拿到的对象一定是不为空的，否则无法执行s.put了。
segment的put方法
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 这里通过tryLock尝试加锁，加锁成功，返回null，否则执行scanAndLockForPut方法
// scanAndLockForPut：
// 如果是多核 cpu 最多 tryLock 64 次, 进入 lock 流程
// 在尝试期间, 还可以顺便看该节点在链表中有没有, 如果没有顺便创建出来
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
// 这里可以保证已经加上锁了
try {
// 当前Segment的table数组
HashEntry<K,V>[] tab = table;
// 这里就是通过hash值，与tab数组长度取模，找到其所在HashEntry数组的下标
int index = (tab.length - 1) & hash;
// 当前下标位置的第一个HashEntry节点
HashEntry<K,V> first = entryAt(tab, index);
// 遍历
for (HashEntry<K,V> e = first;;) {
// 如果第一个节点不为空
if (e != null) {
K k;
// 并且第一个节点，就是要插入的节点，则替换value值，否则继续向后查找
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next; // 不断循环链表更新e
}
// 说明当前index位置不存在任何节点，此时first为null
// 或者当前index存在一条链表，并且已经遍历完了还没找到相等的key，
// 此时first是链表头部
else {
// 如果node不为空，则直接头插
// 这里之之所以不为空是因为在上面尝试加锁的时候有可能初始化
if (node != null)
node.setNext(first);
// 否则，创建一个新的node，并头插
else
node = new HashEntry<K,V>(hash, key, value, first);
// 如果segment中元素大于阈值，扩容
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
// 否则，就把当前node设置为index下标位置新的头结点
else
setEntryAt(tab, index, node);
++modCount;
count = c; //更新count
oldValue = null;
break;
}
}
} finally {
unlock(); // 手动解锁
}
return oldValue;
}
Segment 数组下标和计算 HashEntry 数组下标的不同点：
//下边的hash值是通过哈希运算后的hash值，不是hashCode
// 计算 Segment 下标
(hash >>> segmentShift) & segmentMask
// 计算 HashEntry 数组下标
(tab.length - 1) & hash
// 这是为了尽量避免当前 hash 值计算出来的 Segment 数组下标和计算出来的 HashEntry 数组下标趋于相同
// 让 hash 的高 4 位和 (1)处做与 运算，而用低位和 (2)处做与运算
scanAndLockForPut(): put 方法第一步抢锁失败之后，就会执行此方法， 这个方法可以确保返回时，当前线程一定是获取到锁的状态
这个方法逻辑比较复杂，会一直循环尝试获取锁，若获取成功，则返回。否则的话，每次循环时，都会同时遍历当前链表。若遍历完了一次，还没找到和key相等的节点，就会预先创建一个节点。注意，这里只是预测性的创建一个新节点，也有可能在这之前，就已经获取锁成功了。 同时，当重试次每偶数次时，就会检查一次当前最新的头结点是否被改变。因为若有变化的话，还需要从最新的头结点开始遍历链表。
还有一种情况，就是循环次数达到了最大限制，则停止循环，用阻塞的方式去获取锁。这时，也就停止了遍历链表的动作，当前线程也不会再做其他预热(warm up)的事情。
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
// 根据hash值定位到它对应的HashEntry数组的下标位置，并找到链表的第一个节点
// 注意，这个操作会从主内存中获取到最新的状态，以确保获取到的first是最新值
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
// 重试次数，初始化为 -1
int retries = -1; // negative while locating node
// 若抢锁失败，就一直循环，直到成功获取到锁。有三种情况
while (!tryLock()) {
HashEntry<K,V> f; // to recheck first below
//1.若 retries 小于0
if (retries < 0) {
// 若 e 节点和 node 都为空，
// 则创建一个 node 节点。这里只是预测性的创建一个node节点
if (e == null) {
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0; // 将retries置为0
}
// 如当前遍历到的 e 节点不为空，
// 则判断它的key是否等于传进来的key，若是则把 retries 设为0
else if (key.equals(e.key))
retries = 0;
else // 否则，继续向后遍历节点
e = e.next;
}
//2.若是重试次数超过了最大尝试次数，则调用lock方法加锁。
// 表明不再重试，我下定决心了一定要获取到锁。
//要么当前线程可以获取到锁，要么获取不到就去排队等待获取锁。
// 获取成功后，再 break。
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
//3.若 retries 的值为偶数，并且从内存中再次获取到最新的头节点，
// 判断若不等于first,则说明有其他线程修改了当前下标位置的头结点
// 于是需要更新头结点信息
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
5、rehash()
当 put 方法时，发现元素个数超过了阈值，则会扩容。需要注意的是，每个Segment只管它自己的扩容，互相之间并不影响。换句话说，可以出现这个 Segment的长度为2，另一个Segment的长度为4的情况（只要是2的n次幂）。 这个操作全程在获得segment锁的情况下执行
// node 为新创建的节点
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table; // 当前hahsEntry旧的数组
int oldCapacity = oldTable.length; // 旧数组的容量
int newCapacity = oldCapacity << 1; // 新的容量X2
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]; // 第i个链表
if (e != null) {
HashEntry<K,V> next = e.next;
// 计算hash值再新数组中的下标位置
int idx = e.hash & sizeMask;
// e不为空，且它的下一个节点next为空，
// 则说明这条链表只有一个节点，直接把这个节点放到新数组的对应下标位置即可
if (next == null) // Single node on list
newTable[idx] = e;
// 否则，处理当前链表的节点迁移操作
else { // Reuse consecutive sequence at same slot
// 记录上一次遍历到的节点
HashEntry<K,V> lastRun = e;
// 对应上一次遍历到的节点在新数组中的新下标
int lastIdx = idx;
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
// 计算当前遍历到的节点的新下标
int k = last.hash & sizeMask;
// 若 k 不等于 lastIdx，则说明此次遍历到的节点和上次遍历到的节点不在同一个下标位置
// 需要把 lastRun 和 lastIdx 更新为当前遍历到的节点和下标值。
// 若相同，则不处理，继续下一次 for 循环。
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
// 把和lastRun节点的下标位置相同的链表最末尾的几个连续的节点放到新数组的对应下标位置
newTable[lastIdx] = lastRun;
//再把剩余的节点，复制到新数组
//从旧数组的头结点开始遍历，直到lastRun节点，因为lastRun节点后边的节点都已经迁移完了
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];
//用的是复制节点信息的方式，并不是把原来的节点直接迁移，区别于lastRun处理方式
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
// 所有节点都迁移完成之后，再处理传进来的新的node节点，把它头插到对应的下标位置
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
// 更新当前Segment的table信息
table = newTable;
}
6、get()
先定位到 Segment，然后再定位到 HashEntry ，并未加锁，用UNSAFE方法保持了可见性，如果在扩容过程中，就先从旧表读取内容
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
// 同样的先定位到 key 所在的Segment ，然后从主内存中取出最新的节点
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
// 若Segment不为空，且链表也不为空，则遍历查找节点
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
//找到则返回它的 value 值，否则返回 null
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
7、remove()
和put方法类似
public V remove(Object key) {
int hash = hash(key);
//定位到Segment
Segment<K,V> s = segmentForHash(hash);
//若 s为空，则返回 null，否则执行 remove
return s == null ? null : s.remove(key, hash, null);
}
public boolean remove(Object key, Object value) {
int hash = hash(key);
Segment<K,V> s;
return value != null && (s = segmentForHash(hash)) != null &&
s.remove(key, hash, value) != null;
}
// Segment的remove
final V remove(Object key, int hash, Object value) {
//尝试加锁，若失败，则执行 scanAndLock ，此方法和 scanAndLockForPut 方法类似
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
//从主内存中获取对应 table 的最新的头结点
HashEntry<K,V> e = entryAt(tab, index);
HashEntry<K,V> pred = null;
while (e != null) {
K k;
HashEntry<K,V> next = e.next;
// 匹配到 key
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
V v = e.value;
// value 为空，或者 value 也匹配成功
if (value == null || value == v || value.equals(v)) {
if (pred == null)
setEntryAt(tab, index, next);
else
pred.setNext(next);
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
unlock();
}
return oldValue;
}
8、size()
size 方法需要重点说明一下。爱思考的小伙伴可能就会想到，并发情况下，有可能在统计期间，数组元素个数不停的变化，而且，整个表还被分成了 N个 Segment，怎样统计才能保证结果的准确性呢？我们一起来看下吧
先采用乐观方式，认为在统计 size 的过程中，并没有发生 put， remove 等会改变 Segment 结构的操作。但是，如果发生了，就需要重试。如果重试2次都不成功(执行三次，第一次不能叫做重试)，就只能强制把所有 Segment 都加锁之后，再统计了，以此来得到准确的结果。
public int size() {
// Try a few times to get accurate count. On failure due to
// continuous async changes in table, resort to locking.
final Segment<K,V>[] segments = this.segments; // segment数组
int size; // 统计所有segment中元素的个数
boolean overflow; // 如果size大小超过32位，则标记为溢出为true
long sum; // 统计每个segment中的 modcount 之和
long last = 0L; // 上次记录的 sum 值
int retries = -1; // 重试次数，初始化为 -1
try {
for (;;) {
//如果超过重试次数，则不再重试，而是把所有segment都加锁，再统计 size
if (retries++ == RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
sum = 0L;
size = 0;
overflow = false;
//遍历所有segment
for (int j = 0; j < segments.length; ++j) {
Segment<K,V> seg = segmentAt(segments, j);
// 若当前遍历到的segment不为空，
// 则统计它的 modCount 和 count 元素个数
if (seg != null) {
//累加当前segment的结构修改次数，如put，remove等操作都会影响modCount
sum += seg.modCount;
int c = seg.count;
//若当前segment的元素个数 c 小于0 或者 size 加上 c 的结果小于0，则认为溢出
//因为若超过了 int 最大值，就会返回负数
if (c < 0 || (size += c) < 0)
overflow = true;
}
}
//当此次尝试，统计的 sum 值和上次统计的值相同，则说明这段时间内，
//并没有任何一个 segment 的结构发生改变，就可以返回最后的统计结果
if (sum == last)
break;
last = sum;
}
} finally {
//如果超过了指定重试次数，则说明表中的所有Segment都被加锁了，因此需要把它们都解锁
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
return overflow ? Integer.MAX_VALUE : size;
}
Java8
1、底层数据结构
Node数组 + 链表 + 红黑树 ( 采用的数据结构跟 HashMap1.8 的结构一样 )，并发控制使用 synchronized 和 CAS 来操作
-
JDK1.8底层是散列表**+**红⿊树
-
ConCurrentHashMap⽀持⾼并发的访问和更新，它是线程安全的
-
检索操作不⽤加锁，get⽅法是⾮阻塞的
-
key和value都不允许为null
为什么有了Hashtable 线程安全类还要ConcurrentHashMap
Hashtable是在每个⽅法上都加上了Synchronized完成同步(相当于锁住整个hash表)，效率低下。
ConcurrentHashMap通过在部分加锁和利⽤CAS算法 + Syn来实现同步
2、put()
由于1.8的 CHM 和 HashMap 结构和基本属性变量，还有初始化逻辑都差不多，只是多了一些并发情况需要用到的参数和内部类，因此，不再单独拎出来介绍。在方法中用到的时候，再详细解释。
- 根据 key 计算出 hashcode 。
- 判断是否需要进行初始化。
- 即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自旋保证成功。
- 如果当前位置的
hashcode == MOVED == -1,则需要进行扩容。 - 如果都不满足，则利用 synchronized 锁写入数据。
- 如果数量大于
TREEIFY_THRESHOLD则要转换为红黑树。
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key和null都是不支持为空的
if (key == null || value == null) throw new NullPointerException();
// 计算hash
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(); //初始化表，只有一个线程可以初始化成功。
// 表已经初始化，则找到当前 key 所在的桶，并且判断是否为空
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//若当前桶为空，则通过 CAS 原子操作，把新节点插入到此位置，
//这保证了只有一个线程可以 CAS 成功，其它线程都会失败。
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//若所在桶不为空，则判断节点的 hash 值是否为 MOVED（值是-1）
else if ((fh = f.hash) == MOVED)
//若为-1，说明当前数组正在进行扩容，则需要当前线程帮忙迁移数据
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//这里用加同步锁的方式，来保证线程安全，给桶中第一个节点对象加锁
synchronized (f) {
//recheck 一下，保证当前桶的第一个节点无变化
if (tabAt(tab, i) == f) {
// 如果hash值 >= 0，说明是正常的链表结构
if (fh >= 0) {
binCount = 1;
//从头结点开始遍历，每遍历一次，binCount计数加1
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;
}
}
}
//否则判断是否是树节点。
//否则判断是否是树节点。
//提一下，TreeBin只是头结点对TreeNode的再封装
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;
}
}
}
}
//判断是在同步锁外部，因为treeifyBin内部也有同步锁，并不影响
if (binCount != 0) {
// 如果节点个数 >= 8 转为红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null) // 返回旧的value
return oldVal;
break;
}
}
}
// 给元素个数 + 1, 可能会触发扩容
addCount(1L, binCount);
return null;
}
spread:
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
// 0x7fffffff: 0111 1111 1111 1111 1111 1111 1111 1111
static final int spread(int h) {
// 还多了一步，保证最高位的 1 个 bit 位总是0。
return (h ^ (h >>> 16)) & HASH_BITS;
}
3、initTable()
第一次put时，数组为空时，初始化的方法
从源码中可以发现 ConcurrentHashMap 的初始化是通过自旋和 CAS 操作完成的。里面需要注意的是变量 sizeCtl ，它的值决定着当前的初始化状态。
- -1 说明正在初始化
- -N 说明有N-1个线程正在进行扩容
- 表示 table 初始化大小，如果 table 没有初始化
- 表示 table 容量，如果 table 已经初始化。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 循环判断表是否为空，初始化成功，这里不怕多线程并发因为只有一个操作成功
while ((tab = table) == null || tab.length == 0) {
//sizeCtl 这个值有很多情况，默认值为0，
//当为 -1 时，说明有其它线程正在对表进行初始化操作
//当表初始化成功后，又会把它设置为扩容阈值
//当为一个小于 -1 的负数，用来表示当前有几个线程正在帮助扩容(后边细讲)
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// CAS把sc设置为-1，表明有线程正在初始化，其他失败线程就会自旋
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 检查表是否为空
if ((tab = table) == null || tab.length == 0) {
// 如果sc大于0，则为sc，否则返回默认容量 16。
// 当调用有参构造创建 Map 时，sc的值是大于0的。
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 创建数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// n减去 1/4 n ，即为 0.75n ，表示扩容阈值
sc = n - (n >>> 2);
}
} finally {
//更新 sizeCtl 为扩容阈值
sizeCtl = sc;
}
//若当前线程初始化表成功，则跳出循环。其它自旋的线程因为判断数组不为空，也会停止自旋
break;
}
}
return tab;
}
4、addCount()
若 put 方法元素插入成功之后，则会调用此方法，传入参数为 addCount(1L, binCount)。这个方法的目的很简单，就是把整个 table 的元素个数加 1 。
类比 1.8 的 HashMap ，我们可以搞一个 size 变量来存储个数统计。但是，这是在多线程环境下，需要考虑并发的问题。因此，可以把 size 设置为 volatile 的，保证可见性，然后通过 CAS 乐观锁来自增 1。这样虽然也可以实现。但是，设想一下现在有非常多的线程，都在同一时间操作这个 size 变量，将会造成特别严重的竞争。所以，基于此，这里做了更好的优化。让这些竞争的线程，分散到不同的对象里边，单独操作它自己的数据(计数变量)，用这样的方式尽量降低竞争。到最后需要统计 size 的时候，再把所有对象里边的计数相加就可以了。
上边提到的 size ，在此用 baseCount 表示。分散到的对象用 CounterCell 表示，对象里边的计数变量用 value 表示。注意这里的变量都是 volatile 修饰的。
当需要修改元素数量时，线程会先去 CAS 修改 baseCount 加1，若成功即返回。若失败，则线程被分配到某个 CounterCell ，然后操作 value 加1。若成功，则返回。否则，给当前线程重新分配一个 CounterCell，再尝试给 value 加1。（这里简略的说，实际更复杂）
CounterCell 会组成一个数组，也会涉及到扩容问题。具体参考
https://mp.weixin.qq.com/s/My4P_BBXDnAGX1gh630ZKw
流程：
size 计算实际发生在 put，remove 改变集合元素的操作之中
- 没有竞争发生，向 baseCount 累加计数
- 有竞争发生，新建 counterCells，向其中的一个 cell 累加计数
- counterCells 初始有两个 cell
- 如果计数竞争比较激烈，会创建新的 cell 来累加计数
5、transfer()
需要说明的一点是，虽然我们一直在说帮助扩容，其实更准确的说应该是帮助迁移元素。因为扩容的第一次初始化新表（扩容后的新表）这个动作，只能由一个线程完成。其他线程都是在帮助迁移元素到新数组。
为了方便，上边以原数组长度 8 为例。在元素迁移的时候，所有线程都遵循从后向前推进的规则，即如图A线程是第一个进来的线程，会从下标为7的位置，开始迁移数据。
而且当前线程迁移时会确定一个范围，限定它此次迁移的数据范围，如图 A 线程只能迁移 bound=6到 i=7 这两个数据
此时，其它线程就不能迁移这部分数据了，只能继续向前推进，寻找其它可以迁移的数据范围，且每次推进的步长为固定值 stride（此处假设为2）。如图中 B线程发现 A 线程正在迁移6,7的数据，因此只能向前寻找，然后迁移 bound=4 到 i=5 的这两个数据。
当每个线程迁移完成它的范围内数据时，都会继续向前推进。那什么时候是个头呢？
这就需要维护一个全局的变量 transferIndex，来表示所有线程总共推进到的元素下标位置。如图，线程 A 第一次迁移成功后又向前推进，然后迁移2,3 的数据。此时，若没有其他线程在帮助迁移，则 transferIndex 即为2
剩余部分等待下一个线程来迁移，或者有任何的 A 和B线程已经迁移完成，也可以推进到这里帮助迁移。直到 transferIndex=0 。（会做一些其他校验来判断是否迁移全部完成，看代码）
6、get()
- 根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
- 如果是红黑树那就按照树的方式获取值。
- 就不满足那就按照链表的方式遍历获取值。
- 根据 hash 值计算位置。
- 查找到指定位置，如果头节点就是要找的，直接返回它的 value.
- 如果头节点 hash 值小于 0 ，说明正在扩容或者是红黑树，查找之。
- 如果是链表，遍历查找之。
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.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;
}
else if (eh < 0)
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;
}
小结：1.8 在 1.7 的数据结构上做了大的改动，采用红黑树之后可以保证查询效率（O(logn)），甚至取消了 ReentrantLock 改为了 synchronized，这样可以看出在新版的 JDK 中对 synchronized 优化是很到位的。
7、总结
Java 8 数组（Node） +（ 链表 Node | 红黑树 TreeNode ） 以下数组简称（table），链表简称（bin）
-
初始化，使用 cas 来保证并发安全，懒惰初始化 table
-
树化，当 table.length < 64 时，先尝试扩容，超过 64 时，并且 bin.length > 8 时，会将链表树化，树化过程会用 synchronized 锁住链表头
-
put，如果该 bin 尚未创建，只需要使用 cas 创建 bin；如果已经有了，锁住链表头进行后续 put 操作，元素添加至 bin 的尾部
-
get，无锁操作仅需要保证可见性，扩容过程中 get 操作拿到的是 ForwardingNode 它会让 get 操作在新table 进行搜索
-
扩容，扩容时以链表为单位进行，需要对链表进行 synchronized，但这时妙的是其它竞争线程也不是无事可做，它们会帮助把其它链表进行扩容，扩容时平均只有1/6的节点会把复制到新数组中
-
size，元素个数保存在 baseCount 中，并发时的个数变动保存在 CounterCell[] 当中。最后统计数量时累加即可
Java7 中 ConcruuentHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，它可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变。
.equals(ek))))
return e.val;
}
}
return null;
}
小结：1.8 在 1.7 的数据结构上做了大的改动，采用红黑树之后可以保证查询效率（`O(logn)`），甚至取消了 ReentrantLock 改为了 synchronized，这样可以看出在新版的 JDK 中对 synchronized 优化是很到位的。
#### 7、总结
**Java 8** 数组（Node） +（ 链表 Node | 红黑树 TreeNode ） 以下数组简称（table），链表简称（bin）
- 初始化，使用 cas 来保证并发安全，懒惰初始化 table
- 树化，当 table.length < 64 时，先尝试扩容，超过 64 时，并且 bin.length > 8 时，会将链表树化，**树化过程会用 synchronized 锁住链表头**
- put，如果该 bin 尚未创建，只需要使用 cas 创建 bin；**如果已经有了，锁住链表头进行后续 put 操作，元素添加至 bin 的尾部**
- get，无锁操作仅需要保证可见性，扩容过程中 get 操作拿到的是 ForwardingNode 它会让 get 操作在新table 进行搜索
- 扩容，扩容时以链表为单位进行，需要对链表进行 synchronized，但这时妙的是**其它竞争线程也不是无事可做，它们会帮助把其它链表进行扩容**，扩容时平均只有1/6的节点会把复制到新数组中
- size，元素个数保存在 baseCount 中，并发时的个数变动保存在 CounterCell[] 当中。最后**统计数量时累加即可**
Java7 中 ConcruuentHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，它可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变。
Java8 中的 ConcruuentHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由 Java7 中的 **Segment 数组 + HashEntry 数组 + 链表** 进化成了 **Node 数组 + 链表 / 红黑树**，Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时会转化成红黑树，在冲突小于一定数量时又退回链表。
438
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
