Concurrenthashmap基础
一、和hashmap,hashtable的对比
1.1 不使用hashmap原因
在多线程环境中使用hashmap的put方法会导致hashmap的Entry链表形成一个环形结构,这样在判断链表是否有下一个节点时永远成立,就会死循环获取节点
1.2 不使用hashtable的原因
hashtable只有一个锁,这样一个线程在写数据的时候,另一个线程不能读,也不能写任何数据,必须等待前面的线程写完数据才可以进行读写操作。
二、concurrentashmap
2.1 结构
2.2 重要的字段
- segemnt
代表一种可重入锁(Reentrantlock),一个segment包括一个hashentry数组 - hashentry
每一个元素是一个链表结构
2.3 初始化方法
- 初始化segment数组
segment数组的长度是2的n次方,因为他是通过按位与的散列算法来定位segment的索引 - 初始化segmentshift和segmentmask
- ssshift默认为4,concurrentlevel默认为16
- segmentshift = 32 - sshift
- senmentmask = ssize - 1,默认是15
2.4 定位segment和HashEntry
- 定位segment
- 首先使用一种算法对元素的hashcode进行再散列,减少hash冲突,
- 将第一步得到的hash值再通过hash算法定位到元素
- 定位HashEntry
- 直接使用再散列后的hash值与tab.length-1相与
2.5 get操作
get操作不需要加锁,除非读到的值是空才会加锁重读,hashtable的get操作是需要加锁的。原因是,他将共享变量定义为volitale类型,volitale变量的特点是支持多线程读,但是不支持多线程写。不会读到过期的数据是根据java内存模型的happen before原则,对volitale字段的写入操作优先于对voltale字段的读入操作。
步骤:
- 先定位到segment
- 再定位到hashentry
- 与链表的值一一进行比较,取出对应的值
2.6 put操作
put方法需要对共享变量进行写入操作,为了线程安全,需要加锁。
- 先定位到segment,然后在segment里面进行插入操作
- 判断对segment里面的HashEntry数组进行扩容,再定位元素插入的位置
扩容:
插入元素之前判断是否需要进行扩容,扩容是以原数组2倍容量方式进行扩容,将原来的数据进行再散列,放到新的数组中,Concurrenthashmap不会对整个容器进行扩容,只会对某个segment进行扩容
2.7 size操作
- Segment的count是一个volatile类型的变量,计算整个size时,不能直接将每个segment的count值相加。
- 作法是先尝试不锁住segment的方式来统计各个segment的count,计算两次,看容器是否发生变化,如发生变化,则采用加锁的方法统计每个segment的count值的和。
- 判断容器是否发生变化的方法是,判断modcount的值是否发生变化,put,remove,clean方法都会使modcount的值发生变化。
三、jdk 1.8之后
3.1 安全机制
Node + CAS + synchronized
3.2 加锁方式
- 只锁定当前链表或红黑二叉树的首节点
3.3 ConcurrentHashMap 为什么 key 和 value 不能为 null?
- null有歧义,不知道是没有还是返回结果是null。
3.4 参数
- 容量,负载因子,并发级别
3.5 初始化
- 如果sizeCtl < 0 ,说明另外的线程执行初始化逻辑,就Thread.yield(),让出cpu。
- 初始化失败,他会一直进入循环尝试初始化
- 初始化结束:sizeCtrl记录数组的扩容阈值
/**
* Initializes table, using the size recorded in sizeCtl.
*/
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// 如果 sizeCtl < 0 ,说明另外的线程执行CAS 成功,正在进行初始化。
if ((sc = sizeCtl) < 0)
// 让出 CPU 使用权
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
//sc=n*0.75:此时sc为扩容阈值
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
-1 说明正在初始化
-N 说明有 N-1 个线程正在进行扩容
0 表示 table 初始化大小,如果 table 没有初始化
>0 表示 table 扩容的阈值,如果 table 已经初始化。
- Thread.yield: 让当前线程从运行状态 转为 就绪状态,不会释放锁。
3.6 put
- 判断key,value是否为null,是,抛出异常
- 判断是否初始化,未初始化进行初始化
- 定位到tab,tab位置为null,使用cas方式插入
- 不为Null,给tab位置上锁,是链表,就以链表方式替换或插入,是红黑树以红黑树方式替换或者插入。链表判断当前key是否存在,存在则替换value,不存在则新建节点插入。链表插入完后需要判断是否需要树化,需要则进行树化。
- else if ((fh = f.hash) == MOVED):判断是不是在扩容,是则协助扩容,正在扩容的不能添加。
- 添加完后判断map需不需要扩容:本次添加数据后,数据总数+1,然后统计数据的个数。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) {
//判断节点是否变成树树节点,可能发生改变
if (tabAt(tab, i) == f) {
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;
}
}
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
3.6 get方法
- 通过哈希定位找到位置,如果是当前桶开始的元素则返回
- 如果是链表,则查找返回
- 如果是红黑树,则查找返回
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
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;
}
3.7 扩容
3.8 构造函数
- 传入的是32,实际上是32+32/2+1,即内部最终构造64长度。
- tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
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;
}
3.9 sizecCtrl含义
- 0:未初始化,且默认初始容量为16
- -1:表示正在初始化
-
0:数组未初始化:记录的是容量,数组初始化,记录的是扩容阈值。
- <n:正在扩容的线程个数为n-1。
3.10 addCount
- 尝试给BaseCount进行加1,添加成功则结束。添加失败,需要去到counterCell中进行添加操作。
- 判断counterCell是否为Null,是则初始化counterCell。然后选择counterCell数组的一个位置判断是否有countCell的对象,没有则创建countCell然后对countCel的value进行计数。失败了就进行重试,重新换一个位置进行重试。多次重试对counterCell进行扩容,尝试进行加的操作。
CounterCell[] as; long b, s;
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
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)
return;
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
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();
}
}
}
3.11 扩容
- transfer:容量为原来的2倍,然后进行扩容。
- 每个线程最少负责16个
- 迁移完一个位置,会方一个fwd对象,表示迁移完毕。fwd的哈希值是-1。
- 给每个线程分配任务,从后往前分。
- 每个线程在迁移的时候,给迁移的位置加锁,然后进行迁移操作。位置为null的直接添加fwd,不为null则进行迁移,迁移结束添加fwd。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {}
四、concurrentHashMap方法
4.1 computeIfAbsent方法
public V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
- 判断key对应的value是否存在,不存在则调用mappingFunction(key)计算key的value,如果mappingFunction(key)结果返回null或者抛出异常,则不会存入map。
JAVA8 ConcurrentHashMap.computeIfAbsent 的使用及说明