ConcurrentHashMap的实现原理及源码分析
HashMap是集合框架中非常常用的一个成员，但是HashMap并不是线程安全的。在并发场景下，可以使用Collections类的静态方法synchronizedMap使用线程安全的Map，但是synchronizedMap方法返回的SynchronizedMap实例实际上是通过在各个方法中添加synchronized同步锁来保证线程安全的，频繁的加锁和开锁会导致性能的严重下降。推荐使用ConcurrentHashMap来满足并发场景下对HashMap的需求。
一、实现原理
程序就是算法加数据结构。我们从ConcurrentHashMap的数据结构，以及put方法和扩容方法transfer方法所体现的算法思想，来看一下ConcurrentHashMap的实现原理。
总的来说，ConcurrentHashMap使用了“数组+链表+红黑树”的数据结构。
1、它的基础数据结构，或者说最外层数据结构是数组，链表和红黑树都是存放在数组中的；
2、数组中存放的是Node的实例，Node是ConcurrentHashMap定义的内部类，包括key、value、hash、next等成员属性。顾名思义，key和value就是要存储的键值对；hash一般来说是key的hash值，特殊情况参考第二章第三小节transfer方法源码后面的说明；next执行下一个Node实例；
3、数组中存放的Node实例，对于链表，是链表的头节点；对于红黑树，则是特定封装的一个特殊节点TreeBin，节点中不存储键值对，只有next和hash两个成员属性有意义，hash值为固定值-2，next则指向存储数据的红黑树节点；
4、一个数组的成员中存放的是链表还是红黑树，取决于该位置存储的节点的数量。在JDK1.8的情况下，如果当链表中的节点数量大于等于8，则将链表树化成红黑树的结构；如果红黑树中的元素小于等于6的时候，则将红黑树去树化成链表结构。
5、对于一个key值，ConcurrentHashMap找其在数组中对应位置的方法，并不是遍历数组，而是计算(key的hash)和(数组长度-1)进行逻辑与运算的结果，该结果就是在数组中的位置索引。
6、ConcurrentHashMap扩容的时机：
- 链表中节点数增加到8个及以上的时候，触发树化操作，此时会首先判断数组长度是否小于64，满足条件则扩容；
- 存入新的键值对后，会调用addCount方法对应增加记录的元素个数。当元素个数达到阈值(数组当前长度的0.75倍)会触发扩容
二、重要方法的源码分析
1、put方法
put方法和putIfAbsent方法都是通过putValue方法来实现的。源码及分析如下：
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key和value都不允许为null
if (key == null || value == null) throw new NullPointerException();
// 计算哈希值
int hash = spread(key.hashCode());
// 这里“bin”的概念相当于一组节点（Node链表），即binCount就是链表或者红黑树中的Node实例数
// 当链表中的节点数(binCount)大于或者等于TREEIFY_THRESHOLD(数值为8)的时候会被替换成红黑树
int binCount = 0;
// 循环遍历table中的节点
for (Node[] tab = table;;) {
Node f; int n, i, fh;
// 情况1：table为null或空，此时需要初始化table
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 情况2：key-value放入的目标节点为空
// 目标节点在数组中的index是通过将"数组长度减一的数值"和"key的哈希值"相与得到的
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 利用CAS操作创建目标节点可以避免加锁
if (casTabAt(tab, i, null, new Node(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 情况3：hash = MOVED表示节点类型是ForwardingNode，这种节点只用在resize的过程中
// 说明此时的ConcurrentHashMap实例正在扩容，所以需要当前线程帮忙去完成这个过程
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 情况4：这种就是正常的数组的目标位置已存在节点，此时需要把目标节点放入目标位置的链表或者红黑树中
else {
V oldVal = null;
// 向数组中目标位置的链表或者红黑树中添加目标节点，此时需要加锁
synchronized (f) {
// 这里的判断是在确认目标位置的节点f没有在“发生判断“和”加锁完成“的短暂间隔内被修改过
if (tabAt(tab, i) == f) {
//
if (fh >= 0) {
binCount = 1;
for (Node e = f;; ++binCount) {
K ek;
// 如果节点e的hash和key的hash相等且e.key和key相等，就可以认为Map中已经存在该key了
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
// 如果是putIfAbsent方法，此时就不进行添加了
if (!onlyIfAbsent)
e.val = value;
break;
}
Node pred = e;
// e的下一个节点为null，说明e已经是最后一个节点，说明遍历全部节点后未发现相同key值，
// 此时直接把目标节点加到e的下一个
if ((e = e.next) == null) {
pred.next = new Node(hash, key,
value, null);
break;
}
}
}
// 如果目标节点是红黑树节点，就按红黑树插入值的方式进行插入
else if (f instanceof TreeBin) {
Node p;
binCount = 2;
if ((p = ((TreeBin)f).putTreeVal(hash, key, value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
// 这里同步锁已经解开了
// binCount如果等于0，说明加锁后实际上避开了所有会把元素添加进去的判断
if (binCount != 0) {
// 树化临界值，如果大于这个值，就用红黑树替代链表
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 当前ConcurrentHashMap实例中包含的元素数量加1
addCount(1L, binCount);
return null;
} 获取节点在table数组中的位置：index = hash & (table.length-1)。通过hash和数组长度-1相与，可以得到table.length个不同的结果，正好放入到长度为table.length的数组中。例如table.length=16，那么hash & (16-1) 的结果，只和hash最低的4位有关，hash的高位和0相与都是0。
2、initTable方法
/**
* Initializes table, using the size recorded in sizeCtl.
*/
private final Node[] initTable() {
Node[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// 这里用到成员属性sizeCtl：这里如果sizeCtl小于0，则有其他线程正在进行初始化或者扩容，该操作不允许并行执行，让出CPU
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 用Unsafe类的CAS方法将sizeCtl设置为-1
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 判断table是不是还没有初始化
if ((tab = table) == null || tab.length == 0) {
// sc=sizeCtl如果是0，table就使用默认容量；如果大于0，就使用就使用sizeCtl的值作为容量
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node[] nt = (Node[])new Node[n];
table = tab = nt;
// sc = 3/4 * n. 用移位操作替换乘法，性能会高很多
sc = n - (n >>> 2);
}
} finally {
// 初始化完成，更新sizeCtl的值
sizeCtl = sc;
}
break;
}
}
return tab;
} 注释：
1、成员变量sizeCtl：table初始化和扩容相关的成员属性。
1）初始化过程中：sizeCtl = -1；
2）扩容过程中：sizeCtl为其他负值：-(1+激活的扩容线程数)
3）初始化之前：如果为ConcurrentHashMap实例传入了初始容量，那么sizeCtl为该初始容量；如果没有设置初始容量，那么sizeCtl=0；
4）初始化完成后，sizeCtl指示的是扩容的阈值，这个版本是当前容量的0.75倍
2、Unsafe类的CAS方法：Unsafe类调用native方法实现原子性操作CAS操作，用来通过无锁的方式线程安全地修改属性的值。
这里的CAS方法有4个参数：
1）this：当前ConcurrentHashMap的实例
2）SIZECTL：成员属性sizeCtl在当前ConcurrentHashMap实例中的偏移，用于定位sizeCtl在内存中的位置；
3）sc是CAS操作中sizeCtl的期望值；
4）-1是sizeCtl修改的目标值。
3、transfer方法
/**
* Moves and/or copies the nodes in each bin to new table. See
* above for explanation.
*/
private final void transfer(Node[] tab, Node[] nextTab) {
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 如果传入的nextTab为null，就给nextTab赋一个容量为原tab两倍的新数组
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
Node[] nt = (Node[])new Node[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
int nextn = nextTab.length;
ForwardingNode fwd = new ForwardingNode(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node f; int fh;
// 循环的目的就是--i，从而实现从后到前对table的遍历
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// for循环的第一轮的while循环，一般都是执行到这里然后才能结束while循环的即i的初始值实际上是nextIndex - 1
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;
// 如果复制已经完成，则进行收尾工作。一般这种对应于
if (finishing) {
// nextTable只在扩容期间使用，扩容完成则置空
nextTable = null;
// 将table指向扩容后的数组
table = nextTab;
// sizeCtl表示扩容的阈值，这里sizeCtl = 1.5n，n是原table的容量，即sizeCtl是新table容量的0.75倍
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 这里CAS的目的是令sizeCtl = sizeCtl - 1，表示增加了一个线程来参与扩容
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
// 如果tab[i] == null，则设置tab[i] = fwd
// 对照下一条else if，这里是用来并发控制的
else if ((f = tabAt(tab, i)) == null)
// 这里如果CAS修改失败，advance=false，则下一轮for循环不会进入while循环体，i不会自减，依然访问当前位置的节点
advance = casTabAt(tab, i, null, fwd);
// MOVED是fwd的hash，如果遍历到的元素hash = MOVED，说明这个元素已经被其他线程处理过
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
// 这种情况就是正常的、需要当前线程去复制的节点了
else {
// 对当前节点加锁，同一个节点只需要一个线程处理
synchronized (f) {
// 判断tabAt(tab, i) == f是为了避免在加锁前的短暂时间内节点已经被其他线程修改了
if (tabAt(tab, i) == f) {
Node ln, hn;
// hash >= 0说明这是一个Node的实例；在这里执行函数复制工作
if (fh >= 0) {
int runBit = fh & n;
Node lastRun = f;
for (Node p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
// 这里需要注意的是，当前节点的下一个节点(next)，是上一次循环中创建的节点(ln或者hn)
// 也就是说，随着p=p.next的迭代，实际上创建出来的链表是一个反序链表
if ((ph & n) == 0)
ln = new Node(ph, pk, pv, ln);
else
hn = new Node(ph, pk, pv, hn);
}
// 假设原数组长度n对应的二进制最高位是第x位，那么分别在nextTab的i和i+n位置中保存hash值的二进制中，第x位为0和1节点
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
// 当前线程处理完当前节点，就将当前节点设置为fwd，这样其他线程看到节点内容是fwd就不会再处理了
setTabAt(tab, i, fwd);
advance = true;
}
// 这种情况表示这个位置的节点是树结构的。处理逻辑基本和链表类似
else if (f instanceof TreeBin) {
TreeBin t = (TreeBin)f;
TreeNode lo = null, loTail = null;
TreeNode hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode p = new TreeNode
(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=6)，则去树化，转换成链表形式
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
// 当前线程处理完当前节点，就将当前节点设置为fwd，这样其他线程看到节点内容是fwd就不会再处理了
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
} hash值和节点Node类型的关系：
- 链表节点：hash >= 0
- ForwardingNode：hash=MOVED=-1(构造器中设置)
- TreeBin：hash=TREEBIN=-2(构造器中设置)
- ReservationNode：hash=RESERVED=-3(构造器中设置)
- TreeNode：这种节点只用在TreeBin的内部，所以在数组中检索到的没有这种类型
4、get方法
get方法比较简单，主要是处理了四种情况：直接找到了目标节点，在树节点中查找目标节点，在链表节点中查找目标节点，以及在没找到的时候返回null。
/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code key.equals(k)},
* then this method returns {@code v}; otherwise it returns
* {@code null}. (There can be at most one such mapping.)
*
* @throws NullPointerException if the specified key is null
*/
public V get(Object key) {
Node[] tab; Node e, p; int n, eh; K ek;
// 获取hash
int h = spread(key.hashCode());
// key对应的节点在数组中的index，是通过(table.length-1) & key.hash计算出来的，不需要遍历，降低时间复杂度
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 如果找到的节点key值和要搜索的key相等，就直接返回该节点的value
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// hash值小于0，说明这是红黑树的头结点，直接从树里面去找value
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;
}
(未完待续)