主要为 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节点。