一、ConcurrentHashMap原理
ConcurrentHashMap 是 JUC包里面提供的一个线程安全并且高效的 HashMap。ConcurrentHashMap是Map 的派生类，所以 api 基本和 Hashmap 是类似。
ConcurrentHashMap在JDK1.7和JDK1.8中的区别。
在JDK1.7中：
ConcurrentHashMap采用的Segment分段锁设计。整个map由一个Segment数组组成。而每个Segment都有一个独立的锁，每个Segment是一个包含多个链表的数组，每个数组元素都是一个链表，而链表中的节点就是保存在map中的数据。
而在JDK1.8中：
1、ConcurrentHashMap取消了分段锁的设计，采用Node 数组来保存数据，并且采用 Node 数组中的元素作为锁来实现对每一行数据进行加锁来进一步减少并发冲突的概率。
2、将原本数组+单向链表的数据结构变更为了数组+单向链表+红黑树的结构。这个结构和 JDK1.8 版本中的 Hashmap 的实现结构基本一致。
ConcurrentHashMap源码分析（基于1.8）
说明：
CAS操作是一种基于乐观锁的操作。包含三个参数：内存地址，预期值，新值。操作时会将预期值与内存地址中的值比较，相同就将内存地址的值更新成新值，成功就返回true。否则就返回false。因为是基于乐观锁的，所以常在多线程并发的情况下使用。
put方法
public V put(K key, V value) {
return putVal(key, value, false); //调用putVal方法
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); //对key进行hash操作
int binCount = 0;
//table是一个volatile修饰的对象，表示map中实际存储数据的对象
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0) //是否要初始化
tab = initTable(); //初始化方法
//tabAt方法表示根据下标（第二个参数）从第一个参数传入的对象中拿到值
//i = (n - 1) & hash表示将tab数组的长度减一与key的hash值做按位与运算。结果会在0-（n-1）之间
//这说明map中的数据是根据key的hash值，来计算需要存到table数组的哪个位置
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//f为空，说明该位置还没有数据
//将key-value封装成一个Node对象，并使用CAS操作将它存到table中
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//如果对应的节点存在，判断这个节点的 hash 是不是等于 MOVED(-1)，说明当前节点是ForwardingNode 节点
//说明有其他线程在扩容，那么当前现在直接帮助它进行扩容，因此调用 helpTransfer方法
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
//进入这里，说明tab[i]已经有数据，则需要将key-value加到这个数据的后面，组成链表
V oldVal = null;
//f是table中的元素，也是链表的头节点，将f作为锁，可以将map的锁的粒度降低到table数组元素这一层
synchronized (f) {
if (tabAt(tab, i) == f) { //判断tab[i]这个元素是否被改变
if (fh >= 0) {//头结点的 hash 值大于 0，说明是链表
binCount = 1; //表示当前链表已经存在多少个节点
for (Node<K,V> e = f;; ++binCount) {
K ek;
//判断key-value与根节点的key-value是否相等，相等就替换
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;
//不相等就找下一个节点，没有，就将key-value加到下一个节点上
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
//如果f的类型是tree，则根据红黑树进行更新
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) {
//TREEIFY_THRESHOLD=8。如果当前链表加上这个数据后长度超过了8，则用红黑树来保存数据
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null) //如果是更新数据，则返回旧数据的值
return oldVal;
break;
}
}
}
addCount(1L, binCount); //map的长度+1
return null;
}
initTable方法
说明：
sizeCtl是ConcurrentHashMap中的Node 数组初始化时和扩容的时候的一个控制位标识。0表示Node 数组还没有被初始化。大于0表示下一次扩容的大小。-1表示正在初始化。-N表示有 N-1个线程正在进行扩容操作。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0) //sizeCtl小于0表示已经有线程在执行初始化
Thread.yield(); // lost initialization race; just spin
//CAS操作SIZECTL，如果成功将SIZECTL更新成-1，就可以开始初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
//没设置初始大小就用默认16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
//相当于n*0.75
sc = n - (n >>> 2);
}
} finally {
//设置 sizeCtl 为 sc, 如果默认是 16 的话，那么这个时候sc=16*0.75=12
sizeCtl = sc;
}
break;
}
}
return tab;
}
addCount 方法
CounterCell数组也采用的是分段设计。当多线程下，执行addCount，不同线程增加的计数的值保存在CounterCell数组不同下标的元素下。然后将所有的值相加就是总的值。这里如果采用设置成员变量size来记录集合大小，则势必用上锁，在竞争比较激烈的情况下，size的设置上会出现比较大的冲突反而影响了性能。
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
//判断 counterCells 是否为空， 如果为空，就通过 cas 操作尝试修改 baseCount 变量，对这个变量进
//行原子累加操作(做这个操作的意义是：如果在没有竞争的情况下，仍然采用 baseCount 来记录元素个数)
//2.如果cas失败说明存在竞争，这个时候不能再采用 baseCount 来累加，而是通过CounterCell 来记录
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true; //是否冲突标识，默认为没有冲突
//CounterCell为空则直接调用 fullAddCount
//从CounterCell中随机取出一个数组的位置为空，直接调用 fullAddCount
//通过CAS修改CounterCell随机位置的值，如果修改失败说明出现并发情况,调用fullAndCount
//as[ThreadLocalRandom.getProbe() & m])表示随机取一个CounterCell数组下标中的元素
//Random 在线程并发的时候会有性能问题以及可能会产生相同的随机数
//ThreadLocalRandom.getProbe 可以解决这个问题，并且性能要比 Random 高
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1) //链表长度小于等于 1，不需要考虑扩容
return;
s = sumCount(); //统计 ConcurrentHashMap 元素个数
}
if (check >= 0) { //如果 binCount>=0，需要检查是否要扩容
Node<K,V>[] tab, nt; int n, sc;
//s 表示集合大小，如果集合大小大于或等于扩容阈值（默认值的 0.75）
//并且 table 不为空并且 table 的长度小于最大容量
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n); //生成一个扩容标识，详情看下文resizeStamp说明
if (sc < 0) {//sc<0，也就是 sizeCtl<0，说明已经有别的线程正在扩容了
//这 5 个条件只要有一个条件为 true，说明当前线程不能帮助进行此次的扩容，直接跳出循环
//sc >>> RESIZE_STAMP_SHIFT!=rs表示扩容标识是否和rs相等
//sc==rs+1 表示扩容结束
//sc==rs+MAX_RESIZERS 表示帮助线程已经达到最大值了
//(nt = nextTable) == null)表示扩容已经结束
//transferIndex<=0 表示所有的 transfer 任务都被领取完了
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
当前线程尝试帮助此次扩容，如果成功，则调用 transfer
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
//RESIZE_STAMP_SHIFT=32-RESIZE_STAMP_BITS
//RESIZE_STAMP_BITS =16
//CAS操作SIZECTL的值为rs左移16位+2，
//rs的值由下文可知第16位一定为1，左移16位后，1在最高位上。所以结果一定为负，所以
//SIZECTL为负表示已经有线程在扩容
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount(); // 重新计数，
}
}
}
代码中的二进制运算：
说明：SIZECTL的二进制。前16位表示扩容标记，后16位表示并行扩容的线程数
假设n=16，resizeStamp（16）=Integer.numberOfLeadingZeros(16) | (1 << (16- 1))
numberOfLeadingZeros(16)结果为27，二进制表示:
0000 0000 0000 0000 0000 0000 0001 1011
1左移15位后的二进制位：
0000 0000 0000 0000 1000 0000 0000 0000
这两个数进行按位或运算后的rs值为（结果为32795）：
0000 0000 0000 0000 1000 0000 0001 1011
设置SIZECTL为(rs << RESIZE_STAMP_SHIFT) + 2结果为：
1000 0000 0001 1011 0000 0000 0000 0010
高低位区分计算：
假设n也就是tab数组长度为16。某个数据的hash值7：hash&n为：
0000 0111 & 0001 0000 = 0000 0000 = 0
hash值为23时，hash&n为：
0001 0111 & 0001 0000 = 0001 0000 = 16
因为在put数据时，是通过i = (n - 1) & hash的方式来确定保存到table数据的哪个位置上，n为table数组的长度
假设n=16，hash 分别为7,23，则i分别等于
hash=7 ： 0000 1111 & 0000 0111 = 0000 0111 = 7
hash=23 ： 0000 1111 & 0001 0111 = 0000 0111 = 7
所以这两个数据都存到tab[7]上。
扩容时是n << 1，也就是将n翻倍。，所以16扩容就是32，则i = (n - 1) & hash的值分别为。
hash=7 ： 0001 1111 & 0000 0111 = 0000 0111 = 7
hash=23： 0001 1111 & 0001 0111 = 0001 0111 = 7+16=23
所以扩容后，hash=23的数据存储的位置变成了tab[23],hash=7的位置不变。
resizeStamp方法
static final int resizeStamp(int n) {
//RESIZE_STAMP_BITS =16
//numberOfLeadingZeros方法是返回无符号整数 n 最高位非 0 位前面的 0 的个数
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
fullAddCount方法
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
//获取当前线程的 probe 的值，如果值为 0，则初始化当前线程的 probe 的值,probe 就是随机数
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true; // 由于重新生成了 probe，未冲突标志位设置为 true
}
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
if ((as = counterCells) != null && (n = as.length) > 0) {//CounterCell已经初始化走这里
通过该值与当前线程 probe 求与，获得cells 的下标元素，和 hash 表获取索引是一样的
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell
CounterCell r = new CounterCell(x); // Optimistic create
//cellsBusy == 0并且CAS操作 CELLSBUSY的值改为1,成功
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
//将CounterCell数组对应下标的值指向r对象
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0; //恢复标志位
}
if (created) //操作成功，退出循环
break;
continue; // Slot is now non-empty
}
}
collide = false;
}
//说明addCount方法中cas失败了，并且获取probe的值不为0
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
//指定下标位置的cell值不为空，则直接通过cas进行原子累加，如果成功，则直接退出
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
//如果已经有其他线程建立了新的counterCells或者 CounterCells 大于 CPU 核心数
else if (counterCells != as || n >= NCPU)
//设置当前线程的循环失败不进行扩容
collide = false; // At max size or stale
else if (!collide) //恢复 collide 状态，标识下次循环会进行扩容
collide = true;
//进入这个步骤，说明CounterCell数组容量不够，线程竞争较大，所以先设置一个标识表示为正在扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {// Expand table unless stale
//扩容一倍 2 变成 4
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0; //恢复标识
}
collide = false;
continue; // Retry with expanded table
}
h = ThreadLocalRandom.advanceProbe(h); //更新随机数的值
}
//cellsBusy=0 表示没有在做初始化，通过CAS更新cellsbusy的值表示当前线程正在做初始化操作
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2]; //初始化CounterCell数组，大小为2
rs[h & 1] = new CounterCell(x); //将x也就是元素的个数放在指定的数组下标位置
counterCells = rs; //赋值给 counterCells
init = true; //初始化标识
}
} finally {
cellsBusy = 0; //告诉其他线程初始化完成
}
if (init)
break;
}
//竞争激烈，其它线程占据 cell 数组，直接累加在baseCount变量中
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
transfer方法
transfer方法就是扩容的方法。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
//tab数组的长度默认为16
int n = tab.length, stride;
//将 (n>>>3 相当于 n/8) 然后除以 CPU 核心数。如果得到的结果小于 16，那么就使用 16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
//MIN_TRANSFER_STRIDE=16
//stride 表示每个线程扩容时需要转移的数据链表（tab数组的元素）的个数，
stride = MIN_TRANSFER_STRIDE; // subdivide range
//没扩容前nextTab为null
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
//新建一个nextTab，大小是table的两倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE; //扩容失败，sizeCtl 使用 int 的最大值
return;
}
nextTable = nextTab;
transferIndex = n; //transferIndex赋值为n也就是tab的长度
}
int nextn = nextTab.length;
// 创建一个 fwd 节点，表示一个正在被迁移的 Node，并且它的 hash 值为-1(MOVED)
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
//设置当前线程需要转移的数据在tab数组中的下标范围。bound-i
//这里是将老tab数组的数据分为多个部分，每部分的长度为stride，一个线程处理一部分。
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
//nextIndex赋值transferIndex
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//CAS操作设置transferIndex的值为nextBound
//比较nextIndex即transferIndex也就是tab数组的长度和stride的大小
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
//i<0 说明已经遍历完旧的数组
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {//如果完成了扩容
nextTable = null; //nextTable设置为空
table = nextTab; //更新 table 数组
sizeCtl = (n << 1) - (n >>> 1); //更新阈值(32*0.75=24)
return;
}
// sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2
// 然后，每增加一个线程参与迁移就会将 sizeCtl 加 1，
// 这里使用 CAS 操作对 sizeCtl 的低 16 位进行减 1，代表做完了属于自己的任务
//第一个扩容的线程，执行transfer方法之前，会设置sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) +2)
//后续帮其扩容的线程，执行 transfer 方法之前，会设置 sizeCtl = sizeCtl+1
//每一个退出 transfer 的方法的线程，退出之前，会设置 sizeCtl = sizeCtl-1
//那么最后一个线程退出时：必然有sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，
//即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT
//如果sc-2不等于标识符左移 16 位。如果他们相等了，说明没有线程在帮助他们扩容了。也就是说，扩容结束了。
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 扩容结束了，更新 finising 变量
finishing = advance = true;
// 再次循环检查一下整张表
i = n; // recheck before commit
}
}
//如果tab[i]=null,表示这个位置的数据已经处理完成或没有数据，则将它设置成fwd节点
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
//fwd节点的hash值设置的就是MOVED，也就是-1。表示这是个fwd节点，已经处理完成了
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
//如果都不是，就是有数据的节点，执行转移操作
else {
synchronized (f) {
if (tabAt(tab, i) == f) {
//将同一个链表中的数据按高低位区分，runBit = fh & n
//runBit==0就是低位，不等于就是高位，具体查看上文二进制计算说明
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
//遍历当前的链表，目的是尽量重用 Node 链表尾部的一部分
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) { //如果最后更新的 runBit 是 0，设置低位节点
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);
}
//将低位的链表放在 i 位置也就是不动
setTabAt(nextTab, i, ln);
//将高位链表放在 i+n 位置
setTabAt(nextTab, i + n, hn);
//把旧的tab数组中[i]位置设置成fwd节点
setTabAt(tab, i, fwd);
advance = true;
}
//红黑树扩容处理方式
else if (f instanceof TreeBin) {
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;
}
}
//如果红黑树的长度又小于8，则转成链表
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(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;
}
}
}
}
}
}
helpTransfer方法
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 判断此时是否仍然在执行扩容,nextTab=null 的时候说明扩容已经结束了
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length); //生成扩容标识
//说明扩容还未完成的情况下不断循环来尝试将当前线程加入到扩容操作中
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
//下面部分的整个代码表示扩容结束，直接退出循环
//transferIndex<=0 表示所有的 Node 都已经分配了线程
//sc=rs+MAX_RESIZERS 表示扩容线程数达到最大扩容线程数
//sc >>> RESIZE_STAMP_SHIFT !=rs， 如果在同一轮扩容中，那么 sc 无符号右移比较高位和
//rs 的值，那么应该是相等的。如果不相等，说明扩容结束了
//sc==rs+1 表示扩容结束
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//在低 16 位上增加扩容线程数
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab); //扩容
break;
}
}
return nextTab;
}
return table;//返回新的数组
}
treeifyBin方法
如果table数组中某个链表的长度大于等于8，并且table数组的长度小于64，则将该链表转为红黑树。在扩容后，如果该链表的长度小于8，则重新转为链表
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
//tab 的长度是不是小于 64，如果是，则执行扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) {// 将链表转换成红黑树
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
new TreeNode<K,V>(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
tryPresize方法
private final void tryPresize(int size) {
//对size进行修复 ,主要目的是防止传入的值不是一个2的次幂的整数，
//然后通过tableSizeFor来将入参转化为离该整数最近的2的次幂
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
//下面这段代码和 initTable 是一样的，如果 table 没有初始化，则开始初始化
while ((sc = sizeCtl) >= 0) {
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;
//这段代码和 addCount 后部分代码是一样的，做辅助扩容操作
else if (tab == table) {
int rs = resizeStamp(n);
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);
}
}
}
ConcurrentHashMap的数据模型（只有链表）如下所示：
扩容原理：
ConcurrentHashMap的数据模型（包含红黑树）红黑树：
2269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
