主要为 JDK1.8 的 ConcurrentHashMap
先复习HashMap源码
put过程、hash值计算、索引计算、扩容
HashMap 的源码一段话描述
JDK1.8 HashMap 的底层数据结构是数组 + 链表 + 红黑树。
三个构造方法、空参构造， 容量构造、 容量+负载因子构造。空参构造默认数组长度是16， 带参构造是比传入数字稍大或者等于的2的倍数。
然后是put方法， 插入数据的时候会先初始化数组， 计算元素对应数组下标，方式是Node的hash值 & 数组长度减一。 由于数组长度都是2的整数倍，比如16-1 = 15 就是1111， 刚好也可以最大限度的获取的Hash值的特征。 还有Node的Hash值的计算也是加入了一个扰动， 把HashCode 异或 HashCode 的高16位，更大限度的使获取数组下标的时候能得到更多对象得特征，减少下标碰撞得概率。然后数组是空的直接插入节点，节点相同直接替换， 不同的话就如果是红黑树就执行红黑树的插入，不是就执行链表遍历插入。插入完节点数 >=8 就转化为红黑树或者扩容。 然后容量达到负载就扩容， 扩容的时候，扩为原来的两倍，然后重新把数据拷贝到新数组，拷贝数据的时候不会再次通过Node 的hash值与 长度 - 1 的方式找下标，而是 旧数组长度 & hash值， 如果是1 那么下标就是 原来下标的两倍， 如果是0 下标不变，这和 & 新长度 -1的结果是一样的，但是这种方式更快。
HashMap是线程不安全的，线程不安全主要发生在扩容的时候，如果两个线程并发执行扩容，假设A线程刚执行完迁移数据，数组还没变更成新数组，那B线程插入数据就会插入到旧数组，造成数据丢失。又或者两个线程都执行迁移数据，迁移使用的是尾插法，A、B线程同时迁移同一个桶的两个节点到新数组的同一个桶，就会产生循环链表，下次查询这个数据走到这个链表的时候就会死循环。
ConcurrentHashMap概念
JDK1.7
为了解决HashMap 的线程不安全，我们可以用 HashTable 或者 Collections.synchronizedMap() 方法，但是他们读写都给整个集合加锁，性能很低。
ConcurrentHashMap 就是兼顾性能和线程安全的， 写的时候锁住一小部分，读的时候不加锁
ConcurrentHashMap 由多个 Segment 组成， Segment 本身就相当于一个 HashMap对象
有 2 的 N 次方个Segment ，共同保存在一个名为 Segment 的数组中。 可以说 ConcurrentHashMap 是一个二级哈希表。
核心属性：
Segment是一个内部类
static final class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
// 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
transient volatile HashEntry<K,V>[] table;
transient int count;
transient int modCount;
transient int threshold;
final float loadFactor;
// ...
}
JDK1.8
JDK1.8 摈弃了Segment的概念，而是直接使用 Node数组 + 链表 + 红黑树。为了兼容旧版本保留了简单的Segment数据结构。
根据hash表的特性，具有冲突的操作只会出现在同一槽位，而与其它槽位的操作互不影响。
基于此种判断，那么就可以将资源锁粒度缩小到槽位上，这样热点一分散，冲突的概率就大大降低，并发性能就能得到很好的增强。
Node是一个内部类，和HashMap中的一样
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
//...
}
通过什么保证线程安全
通过使用Synchroized关键字来同步代码块，而且只是在put方法中加锁，在get方法中没有加锁
加锁时是使用头节点作为同步锁对象。
并且定义了三个原子操作方法
tabAt()
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
tabAt方法相当于 tab[i], 作用是寻找指定数组在内存中 i 位置的数据。
为什么不用 tab[i], 原因是：
虽然table数组本身是增加了volatile属性， volatile 写操作 happen-before 于 volatile 读操作。其他线程对 table 数组的修改均对 get 可见，但是 table 数组 只针对数组的引用具有可见性， 而对他的元素没有可见性。 所以当前线程读取的不一定是最新值。
出于性能考虑，就使用了 Unsafe类 来对 table 进行操作
casTabAt()
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
利用 CAS 算法， 设置node节点上的值。 比较线程私有空间的值和内存中的值是否相等，相等的话就更新， 不相等就不操作
setTabAt()
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
利用 volatile 方法设置第 i 个节点的值，这个方法在写之前添加了 （write_barrier）写屏障， 保证了数据可见性及有序性。
对setTabAt的调用始终发生在锁定区域内
下面开始一步步看源码
初始化
ConcurrentHashMap chm = new ConcurrentHashMap(32);
// 这个在 JDK1.7 初始容量是32， 1.8 是 比 1.5 * 32大一些的2的整数次 = 64
sizeCtl
- sizeCtl为0， 表示数组未初始化， 且数组的初始容量为16
- sizeCtl为正数， 如果数组未初始化，记录的是数组的初始容量， 如果隐居初始化记录的是扩容阈值（数组初始容量 * 0.75）
- sizeCtl为-1， 表示数组正在初始化
- sizeCtl为负数且不是 -1， 表示数组正在扩容， -（1 + n） 表示有 n 个线程正在共同完成扩容的工作
initTable()方法，初始化数组
initTable()方法是没有加锁的， 那么怎么处理并发呢？
sizeCtl为-1， 表示数组正在初始化， sizeCtl为-n， 表示正在由 n - 1 个线程共同完成扩容操作
sizeCtl < 0 就释放CPU资源，因为此时要么是由其他线程在初始化数组，要么是有其他线程都到扩容了， 当前线程就不用初始化了
tab = null 且 sizeCtl >= 0 的时候说明数组还没初始化，
要出初始化的时候通过CAS操作将sizeCtl置为-1，而sizeCtl由volatile修饰，保证可见，这确保多个线程同时只有一个线程能进入初始化。
然后这个方法以是 自旋的方式确保初始化成功。
如果一个线程已经初始化了数组，然后和它同时进来的在自旋的线程再次CAS修改成功的话,会进行一次 double check ,tab不为空了就出去了
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// CAS + 自旋的方式 保证线程安全
while ((tab = table) == null || tab.length == 0) {
//sizeCtl < 0 表示正在做初始化，或者正在做扩容， 这时候就不要再做初始化了
if ((sc = sizeCtl) < 0)
//放弃当前cpu的使用权，让出时间片，线程计入就绪状态参与竞争
Thread.yield(); // lost initialization race; just spin
// compareAndSwapInt 原子操作， 看 sc 和 SIZECTL 是不是相等的，相等的话就把 SIZECTL 赋值为-1， 设置成功返回true，
// 设置失败说明有其他线程已经改变了 SIZECTL 的值
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
//进行一次 double check 到这的时候前面有个线程刚完成了初始化
if ((tab = table) == null || tab.length == 0) {
//给了初始值， sc就 > 0， 是由给定的初始值计算出来的 ， 如果没给初始值，就用默认初始值16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
//new 了一个长度为 n 的数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// sc = 0.75 * n, 位运算效率高
sc = n - (n >>> 2);
}
} finally {
//初始化完， 此时 sizeCtl > 0 是数组容量 * 0.75
sizeCtl = sc;
}
break;
}
}
return tab;
}
put操作
源码：
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException(); //有null直接抛空指针异常
// spread： (h ^ (h >>> 16)) & HASH_BITS 获取key的 hash值。
//和HashMap操作一样， 多一个& HASH_BITS 保证最高位为0，即保证正数
int hash = spread(key.hashCode());
int binCount = 0;
//CAS经典写法，不成功无限重试，让再次进行循环进行相应操作。
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//如果tab是空的，则会初始化数组，这里的初始化数组只允许一个线程去初始化。
if (tab == null || (n = tab.length) == 0) tab = initTable();
// tabAt() 是 UnSafe 类的方法， 是CAS的取法， 保证可见性（取到的是最新值）
// 该位置为null，则可以直接进行cas的put操作，不用加锁，失败会自动到外层循环并进行重试
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//以cas方式进行插入，只有 tab[i] 为 null 的时候插一个节点进入。
//如果两个线程同时走到这里，只有一个成功，成功的结束循环，不成功的继续在外层循环
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// f 是取出的tab[i]位置的节点， 这位置不为空了， 那就看 f 节点的 hash 值， 如果hash == -1 说明这个节点是正在扩容的节点。
// 节点正在扩容，当然就不能再往这插入了， 这个数组已经是一个旧数组了，插到这也没用啊
// 既然正在扩容，那就协助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 如果 tab[i] 位置不为空， 且不是forward节点（没有在扩容）， 那就往这个节点后面插入数据
else {
V oldVal = null;
//把 tab[i] 位置节点锁住， 保证 tab[i] 这个桶， 只有一个线程再插入节点
synchronized (f) {
//double check，再次以可见性的方式获取tab[i] 位置，看他还是不是 f
//防止有线程做完插入， 把这个桶的内容变成了红黑树，这个线程来了，拿到了f， 但是桶里第一节点已经变了。此时重新走一遍
if (tabAt(tab, i) == f) {
//tab[i] 桶位 还是这个节点， 然后 fh >= 0 表示这个节点是链表
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;
}
}
}
}
//到这如果是 链表形式的插入完成binCount =链表长度，如果是红黑树形式的插入成功 binCount = 2。
//binCount = 0 肯定是没插入成功，那就重新走一遍
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
//bitCount >= 8 变红黑树， 也不是一定变成红黑树，如果数组容量小于 64 会以扩容的方式来避免变树操作
//为什么是 8 跟泊松分布有关，到8了说明之后还放到这个槽位的概率更高点了
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// tab为空也初始化了。
// 初始化完， tab[i]为空的话CAS 直接插入了。 不为空的话锁住tab[i] 槽位， 以链表或红黑树插入了
// 该变树变树了，不想变树扩容重分配了
// 这时候该判断是不是要扩容了
addCount(1L, binCount);
return null;
}
spread()方法
static final int spread(int h) {
//和HashMap中的一样， 使高16位也有参与感。 然后 & HASH_BITS 保证最高位为0
return (h ^ (h >>> 16)) & HASH_BITS;
}
addCount() 方法
计算维护集合长度， 长度计算方式是 有一个baseCount 对其进行CAS加，
如果加不上就建个CounterCell数组， 找一个位置的CounterCell ， 对它的value进行CAS加
最后长度是CounterCell数组的value 之和 + baseCount
put 添加元素完毕会调用 addCount()， 维护集合大小，并判断是否需要扩容
private final void addCount(long x, int check) {
// 维护集合的大小 （size）
CounterCell[] as; long b, s;
// 刚来 as肯定为null, 第二个条件， CAS 判断主存的 BASECOUNT 和 当前线程的 baseCount 是否相同， 相同的话就给 BASECOUNT + 1
// 如果加成功了， 那么 BASECOUNT长度维护成功。如果加失败了， 就进入 if 执行体
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true; // 表示默认没有冲突，即无竞争
//第一次进来数组肯定为空， 然后进入if执行体，执行 fullAddCount(x, uncontended)
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
// 计算元素个数 baseCount+x（1.竞争，2.无竞争）
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
// check就是 bincount， 从putVal方法过来的 check
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// sizeCtl 是集合扩容阈值， 如果集合大小 >= 扩容阈值并且tab初始化过了，并且 tab数组长度小于 2的30次方
// 就扩容， 如果发现
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
//sc < 0 正在扩容， 那么就协助扩容
if (sc < 0) {
//判断当前扩容
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);
s = sumCount();
}
}
}
fullAddCount() 方法
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
//ThreadLocalRandom.getProbe() 类似 hash 值， 计算数组下标的
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = 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) {
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell
CounterCell r = new CounterCell(x); // Optimistic create
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
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;
}
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
else if (!collide)
collide = true;
// cellsBusy 初始值就是 0， CAS把 cellsBusy值改为 1， 只允许一个线程，成功的那个线程进入对数组初始化
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
//对 数组 初始化
if (counterCells == as) {// Expand table unless stale
//
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);
}
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];
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
sumCount()方法
集合大小 = baseCount + counterCells中的每个value
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
总结
JDK1.7 是 Segment + 数组 + 链表， 形成的类似二级hash的结构。JDK 1.8 把锁的粒度控制的更小，底层数据结构变成了是 数组 + 链表 + 红黑树。 它通过CAS + 自旋 + synchronized 关键字进行并发控制。synchronized 只在插入的时候锁数组的一个桶位。
JDK 1.8 带参构造传入初始容量，最终确定的数组长度是比传入数的1.5倍稍大 2 的整数次方， 比如传入 15 最后数组长度是32， 这个和 HashMap是有点不一样的。
然后 putVal 方法， 空键空值会抛异常。然后死循环的方式确保插入成功才跳出。 如果数组为空，执行initTable()，这个方法是通过CAS + 自旋的方式， 确保只有一个线程能进行扩容。
具体说就是有一个 volatile 的 sizeCtl 属性， 它的值为-1 的时候说明正在初始化， 值为其他负数说明正在扩容。
值为 0 说明还没初始化且初始化容量是16， 值为正数 如果还没初始化，就是sizeCtl 就是初始容量的值，如果初始化过了 sizeCtl 就扩容阈值。
CAS确保只有一个线程去初始化数组，自旋确保数组能初始化成功，自旋如果发现其他线程正在扩容会执行Thead.yield()方法，让出CPU时间片，从运行线程变成就绪线程。
初始化完，tabAt() 方法，以可见性的方式获取数组tab[i] 的桶位， 桶位为空直接以CAS 的方式插入节点。桶位是forward节点就去协助扩容，协助完扩容再插入，桶位既不为空也不是forward节点，就用 synchonized 代码块，锁住桶位的第一个节点。 这样锁的粒度就控制在了数组的一个桶位上，效率就很高了，插入后桶位然后节点 >= 8 尝试变红黑树，如果数组长度小于64，会以扩容重新分配节点，而不是变红黑树。
执行完插入， 会计算集合大小，如果大小达到扩容阈值会进行扩容。如果只有一个线程插入，那直接大小 +1 即可，但是并发情况很多个线程都给 BaseCount +1 的话，由于volatile 只能保证可见性， 写操作 happen-before 于 volatile 读操作， 其他线程写完，我再从主存读到工作线程的话数据正确的，但是如果其他线程还没写，我就读到工作线程了，那读到的就是旧数据，两个线程同时完成+1，刷回主存，数字总共就只 +1，而不是 +2。用原子+是可以解决这个问题的。 但这里ConcurrentHashMap 是引入了一个CounterCell数组， 通过对 BaseCount 或 CounterCell数组中的value进行CAS +1操作来完成的。这样效率是更高的，如果有很多线程同时++的话也不会自旋太久。最后计算 BaseCount 和 CounterCell 数组的和得到集合大小。
如果集合大小达到了扩容阈值， 就会扩容， 扩容采用的是一个并发扩容机制。 如果 sizeCtl 为负数，就是正在扩容， 当前线程就会进行协助扩容。并发扩容主要用了一个分片的思想，每个线程划分任务，任务量是CPU根据CUP核数计算的，最小任务量是16个桶位的位移。也是两倍扩容，如果迁移桶位为空直接插入一个forward节点， 桶位不为空就用synchronized 锁住桶位进行迁移，迁移完了在这个桶位放一个forward节点。
1095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
