目录
一、JDK8中ConcurrentHashMap的特点
JDK8中的实现有很大的变化，首先没有了分段锁，所有数据都放在一个大的HashMap中，其次是引入了红黑树。
如果头节点是Node类型，则尾随它的就是一个普通的链表；
如果头节点是TreeNode类型，它的后面就是一颗红黑树，TreeNode是Node的子类。
链表和红黑树之间可以相互转换；初始的时候是链表，当链表中的元素超过某个阈值时，把链表转换为红黑树；反之，当红黑树的元素个数小于某个阈值时，再转换为链表。
二、为什么要做出这样的改变？
JDK7中的分段锁有三个好处：
1、减少Hash冲突，避免一个槽里面有太多元素。
2、提高读和写的并发度。段和段之间相互独立。
3、提供扩容的并发度。扩容的时候，不是整个ConcurrentHashMap一起扩容，而是每个Segment独立扩容。
JDK8中相应的处理方式：
1、使用红黑树，当一个槽里的元素过多时，其查询和更新速度比链表快的多，Hash冲突的问题由此得到了很好的解决。
2、加锁的粒度，并非整个ConcurrentHashMap，而是对每个头节点加锁，即并发度就是Node数组的长度，初始长度为16，和在JDK7中的Segment的个数相同。
3、并发扩容。在JDK7中Segment的个数初始化时一旦确立，不能再改变，并发度被固定。之后只是在每个Segment内部扩容，这意味着每个Segment独立扩容互不影响，不存在并发扩容的问题。
但在JDK8的实现一方面降低了Hash冲突，另一方面也提高了并发度。
三、实现分析
1、构造函数分析
public ConcurrentHashMap() {
}
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;
}
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
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;
}
变量cap就是Node数组的长度，保持为2的整数次方。这里的sizeCtl其含义适用于控制在初始化或者并发扩容时候的线程数，初始值为cap。
sizeCtl变量的含义：
1、当sizeCtl=-1的时候表示整个HashMap正在初始化。
2、当sizeCtl=某个其他负数时，表示多个线程在对HashMap做并发扩容。
3、当sizeCtl=cap时，tab=null，表示未初始化的初始容量。
4、扩容成功后，sizeCtl存储的是下一次要扩容的阈值。默认阈值为0.75
2、初始化
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 判断：数组是否初始化
while ((tab = table) == null || tab.length == 0) {
// 判断：当前table是否正在初始化或扩容
if ((sc = sizeCtl) < 0)
Thread.yield();
// 以CAS方式，将sizeCtl设置为-1（-1表示当前table数组正在初始化）
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// Double Check
if ((tab = table) == null || tab.length == 0) {
// sizeCtl > 0，则作为长度，sizeCtl == 0，默认16长度
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// table初始化完成
table = tab = nt;
// 计算下次扩容的阈值，赋值给sc
sc = n - (n >>> 2);
}
} finally {
// sc赋值给sizeCtl
sizeCtl = sc;
}
break;
}
}
return tab;
}
多个线程的竞争通过对sizeCtl进行CAS操作实现的。如果某个线程成功的把sizeCtl设置为-1，它就拥有了初始化的权利，初始化完成后，将sizeCtl设置回去。
3、put实现分析
public V put(K key, V value) {
return putVal(key, value, false);
}
/**
* 如果table或bucket未初始化，则不加锁，通过CAS保证并发安全性
* 其他情况加synchronized锁，锁的是bucket[0]元素
*
* @param key 键
* @param value 新值
* @param onlyIfAbsent true:不存在时才会put
* @return 旧值
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 1.计算key的哈希值hash
int hash = spread(key.hashCode());
int binCount = 0;
for (ConcurrentHashMap.Node<K,V>[] tab = table;;) {
// f：bucket存储的根节点数据（链表或红黑树）
// n：table数组长度
// i：key对应的数组索引
// fh：f对应的hash值
ConcurrentHashMap.Node<K,V> f; int n, i, fh;
// 2.如果：table尚未初始化
if (tab == null || (n = tab.length) == 0)
// 初始化table
tab = initTable(); // 初始化表无锁
// 3.如果：bucket尚未使用
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果：CAS创建bucket成功
if (casTabAt(tab, i, null,
new ConcurrentHashMap.Node<K,V>(hash, key, value, null)))
// 退出循环，put完成
break;
}
// 4.如果：table[i]处于扩容rehash状态中
else if ((fh = f.hash) == MOVED)
// 帮助table[i]进行扩容，并将tab指向newTable
tab = helpTransfer(tab, f);
else {
// 解决哈希冲突，将元素添加到到链表或红黑树中
V oldVal = null;
// 5.锁住bucket的第一个元素（头节点、根节点），进行put操作
synchronized (f) {
// double check
if (tabAt(tab, i) == f) {
// 如果：bucket为链表结构
if (fh >= 0) {
binCount = 1;
for (ConcurrentHashMap.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;
// 根据onlyIfAbsent选择性更新该value
if (!onlyIfAbsent)
e.val = value;
break;
}
ConcurrentHashMap.Node<K,V> pred = e;
// 如果：遍历到了bucket最后一个node
if ((e = e.next) == null) {
// 创建新node并链接在其尾部
pred.next = new ConcurrentHashMap.Node<K,V>(hash, key, value, null);
break;
}
}
}
// 如果：bucket为树结构
else if (f instanceof ConcurrentHashMap.TreeBin) {
ConcurrentHashMap.Node<K,V> p;
binCount = 2;
if ((p = ((ConcurrentHashMap.TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 6.如果：bucket中的节点数大于等于8
if (binCount >= TREEIFY_THRESHOLD)
// 扩容或转为红黑树
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 7.
addCount(1L, binCount);
return null;
}
一共有四种情况
1、数组未初始化，进行数组初始化
2、所在的槽为空，当前元素是槽的第一个元素，直接新建一个头节点CAS设置。
3、当前槽正在扩容，帮助其扩容。
4、把元素放入槽内。槽内可能是一个链表，也可能是一个红黑树，通过头节点的类型可以判断出是哪一种。使用synchronized关键字对数组下标的头节点加锁。当元素个数超过8个时，把链表转换为红黑树，也就是treeifyBin(tab,i)函数。但在这个函数内部，不一定需要进行红黑树转换，可能只做扩容操作。尾插
4、扩容
首先从treeifyBin(tab, i)讲起。
/**
* 替换给定索引处 bin 中的所有链接节点，除非表太小，在这种情况下，改为调整大小。
*/
private final void treeifyBin(ConcurrentHashMap.Node<K,V>[] tab, int index) {
ConcurrentHashMap.Node<K,V> b; int n, sc;
if (tab != null) {
// 1.如果：table长度小于64
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 扩容为2倍长度
tryPresize(n << 1);
// 2.如果：bucket不为空且为链表结构
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 锁住bucket第一个节点
synchronized (b) {
if (tabAt(tab, index) == b) {
ConcurrentHashMap.TreeNode<K,V> hd = null, tl = null;
// 3.将此bucket的所有链表节点转为树节点，并按原顺序将这些树节点组织成双向链表
for (ConcurrentHashMap.Node<K,V> e = b; e != null; e = e.next) {
ConcurrentHashMap.TreeNode<K,V> p =
new ConcurrentHashMap.TreeNode<K,V>(e.hash, e.key, e.val, null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
// 4.将TreeNode由链表结构转化为红黑树结构
setTabAt(tab, index, new ConcurrentHashMap.TreeBin<K,V>(hd));
}
}
}
}
}
当数组长度没有超过64的时候，数组的每个节点里都是链表，只会扩容，不会转换成红黑树。只有当数组长度大于或者等于64的时候才将链表转换为红黑树。
private final void tryPresize(int size) {
// 对扩容数组长度作判断，保证其不超过阈值，并且是2的n次幂
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
// 两种可能：1.未初始化数组（putAll方法）2.初始化数组
Node<K,V>[] tab = table; int n;
// 判断：数组是否初始化
if (tab == null || (n = tab.length) == 0) {
// 进行初始化
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
// 如果扩容长度小于扩容阈值
// 数组长度已经大于等于最大长度
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
// 扩容
else if (tab == table) {
// 获取扩容戳（32位数值，高16位为扩容标识，低16位为扩容线程数）
int rs = resizeStamp(n);
// sc小于0，当前正在扩容
if (sc < 0) {
// 帮助扩容
Node<K,V>[] nt;
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 当前没有正在扩容，设置扩容标识，开始扩容
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
tryPresize是根据期望的元素个数对整个Hash表进行扩容，核心是调用transfer函数。在第一次扩容的时候，sizeCtl会被设置为一个很大负数，之后每一个线程扩容的时候sizeCtl+1，每一个线程扩容完成之后，sizeCtl减1。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) { //tab是旧数组，nextTab是新数组
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) //计算步长，(n/8)/NCPU，最小值是16
stride = MIN_TRANSFER_STRIDE; // subdivide range
if (nextTab == null) { // 新数组为空，初始化
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; //扩容，*2
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n; //transferIndex：多线程下，数组从后往前遍历挨个元素转换，transferIndex 表示下个线程应该转换旧数组的哪个元素
}
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); //ForwardingNode是个特殊的Node对象，hash值为MOVED（-1）
boolean advance = true; //当前线程是否继续往前找未转移的元素
boolean finishing = false; // 当前线程的扩容逻辑是否做完（只是当前线程）
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound; //nextIndex是跳过的右边界，nextBound是跳过的左边界，左闭右开
//不越界的情况下，nextIndex - nextBound = stride（步长）
if (--i >= bound || finishing) //倒着遍历
advance = false;
else if ((nextIndex = transferIndex) <= 0) { //旧数组已经转换到下标0的位置了
i = -1;
advance = false;
}
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) { //数组是从右往左遍历，如果越界（负数），下标就设置为0
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
nextTable = null;
table = nextTab; //转移到新的数组
sizeCtl = (n << 1) - (n >>> 1); // *2*0.75
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { //每有一个线程帮助扩容完，sc就-1
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
//这个逻辑相当于： sc != (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2 ，
//(resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2 是第一个线程执行扩容时，sc 设置的初始值，之后每有一个线程帮忙扩容，就在 sc 的初始值上 + 1
return; //当前线程扩容执行完毕
// 当 sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2 时，会走到这儿，表示除了当前线程，其它所有帮助扩容的线程都执行完了
finishing = advance = true; //表示所有线程扩容执行完毕
i = n; // recheck before commit
}
}
else if ((f = tabAt(tab, i)) == null) //数组对应位置是null
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED) //数组对应位置已被其它线程处理
advance = true; // 循环处理前一个位置
else {
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) { //数组中对应位置是链表
// 链表在扩容时会分成高位和低位（和HashMap相同），假设单向链表最后一位是高位，然后往前推，反向遍历，runBit就指向链表节点第一次变成低位时的后一个高位节点
// 即在原链表中，runBit指向的节点为头的单向链表，要么都是低位的，要么都是高位的
int runBit = fh & n; //指向链表最后相同位的节点
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) { //遍历链表，找出runBit节点的位置
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) { //将runBit后的节点整个挪到新数组
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) { //遍历剩余节点，往新数组插
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0) //低位
ln = new Node<K,V>(ph, pk, pv, ln); //头插法
else //高位
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln); //往新数组中设置值
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd); //往旧数组中设置fwd
advance = true;
}
else if (f instanceof TreeBin) { //如果数组中的元素是红黑树，与HashMap逻辑相同
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(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;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : //小于6，红黑树退化成链表
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
扩容的具体过程：
1、首先建一个新的HashMap，其数组长度为旧数组长度的两倍，然后把旧的元素逐个迁移过来。该函数会被多个线程调用，所以每个线程知识扩容旧的部分的HashMap。涉及到任务划分问题。
2、多个线程并发扩容，每个线程只用扩容一段，一段的长度用变量stride来表示，transferIndex表示了整个数组扩容的进度。
stride的计算：在单核模式下stride=数组长度，因为单核模式下没有办法多个线程并发扩容。
多核模式下为(n>>>3)/NCPU，并且保证步长的最小值为16，需要的线程数位n/stride。
transferIndex通过CAS，每次减stride来进行任务分派。
3、在线程扩容未完成之前，有的数组下标已经迁移完毕，有的还在旧的HashMap中，当使用get的时候还是会访问旧的HashMap，怎么处理呢？新建一个ForwardingNode即转发节点，在这个节点里记录的是新的ConcurrentHashMap的引用。当线程访问到ForwardingNode后，会去查询新的ConcurrentHashMap。
4、同JDK7，每次迁移的时候，最后末尾一段Hash值相同的段，一起进行迁移。
530
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
