注:本博客资源来自于享学课堂,自己消化之后有修改
目录
使用
除了map有的线程安全的put和get方法外,ConcurrentHashMap还有在并发下的public V putIfAbsent(K key, V value),如果key已经存在,直接返回value的值,不会进行替换。如果key不存在,就添加key和value,返回null,并且它是线程安全的。
在1.7下ConcurrentHashMap实现分析
在1.7下的实现原理图
备注:建议有想画这种图的同学,可以使用processon,非常好用
ConcurrentHashMap是有Segment数组结构和HashEntry数组组成,hashEntry每个元素是链表;Segment继承ReentrantLock,是一种可重入锁,ConcurrentHashMap上锁就是在Segment上。
HashEntry是一个数组,每个数组元素存放的是一个链表,每次对链表元素进行修改的时候,都必须获得数组对应的Segment锁
构造方法和初始化
public ConcurrentHashMap17(int initialCapacity,float loadFactor, int concurrencyLevel)
参数说明
参数 | 描述 | 默认值 |
initialCapacity | ConcurrentHashMap初始容量,默认是 | DEFAULT_INITIAL_CAPACITY=16 |
loadFactor | 负载因子阈值,用于控制大小调整。initailCapacity*loadFactor=HashMap的容量,负载越大,链表的数据越多,查找难度就会变大,负载越小,链表数据越少。 | DEFAULT_LOAD_FACTOR = 0.75f |
concurrencyLevel | 估计并发级别,即可能会有多少个线程共同修噶爱这个map,以此来确定Segment数组大小,默认是16,必须是2的备注,如果设置17,正是就是32 | DEFAULT_CONCURRENCY_LEVEL = 16 |
get操作
get操作先经过一次再散列的到A,然后通过|A高位获取到Senment[]的位置,然后通过A全部散列定位到在table[]中的位置。整个过程没有加锁,而是通过volatile保证get可以拿到最新值。
transient volatile HashEntry<K,V>[] table;
public V get(Object key) {
Segment<K,V> s;
HashEntry<K,V>[] tab;
//准备定位hash的值
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
//拿到segment下的table数组
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
//遍历table下的HashEntry链表
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
put操作
ConcurrentHashMap初始化的时候,会初始化Segment[0],其他的Segment在插入第一个值的时候才会初始化
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
//定位所需要的hash值
int hash = hash(key);
//定位到元素在Segment[]数组中的位置
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null)
//初始化Segment[j],因为整个map初始化的时候,只初始化了segment[0]
s = ensureSegment(j);
//把元素放到对应的Segment元素中
return s.put(key, hash, value, false);
}
s = ensureSegment(j);
多个线程进入同一个Segment[k],只要有一个成功就行了,使用CAS保证并发
s.put(key, hash, value, false);
Segment.put方法会舱室获得锁,如果没有获得所,调用scanAndLockForPut方法自旋等待获得锁
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
scanAndLockForPut通过while自旋获取锁
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
。。。
while (!tryLock()) {
。。。
}
return node;
}
获取锁之后,如果摸个HashEntry节点有相同的key,就更新HashEntry的value值;否则新建已给HashEntry节点,采用头插法把他设置为链表的新head节点,并将原节点设置为head的下一个节点
新建过程中如果节点数超过threshold,就会调用rehash()对Segment中的数组进行扩容
扩容rehash操作:对table扩容
对table扩容成两倍的时候,有些值在数组中的下标未变,有些值会变化为i+capacity,举例如下
原table长度是capacity=4,元素在table中位置
hash值 | 15 | 23 | 34 | 56 | 77 |
在table中下标 | 3=15%4 | 3=23%4 | 2=34%4 | 0=56%4 | 1=77%4 |
扩展一倍之后,通过这个方法,可以快速定位和减少元素重拍的次数
hash值 | 56 | 34 | 77 | 15,23 | ||||
下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
计算 | i | i | i+capacity=1+5=5 | i+capacity=3+4=7 |
remove操作
和put方法类似,都是在操作之前要拿到锁,以保证操作的线程安全性
ConcurrentHashMap的弱一致性
遍历链表中是否有形同key以获得value。但是由于遍历过程中,其他线程可能对链表结果做了调整,因此get和containsKey方法返回的可能是已经过时的数据,这一点是ConcurrentHashMap在弱一致性上的体现。如果要求强一致性,那么必须使用Conllections.synchronizedMap()方法
在多线程下避免使用size、containsValue方法
在循环的方法判断两次,每个Segment中所有元素个数的和两次相等才返回值,否则循环次数超过预定义值,就会对Segment进行加锁,影响性能
在1.8下ConcurrentHashMap实现分析
1.8对ConcurrentHashMap的改进
1、取消Segment字段,直接采用transient volatile HashEntry<K,V>[] table保存数据,直接采用table数组元素作为锁,从而实现了缩小锁的粒度,提高了效率
2、原来是table数组+单项链表;现在是table数组+单向链表+红黑树结构(因为如果某一个链表数据过长,单链表查询就必须一个个遍历,效率低,数据多的时候,把链表转换为红黑树,可以提高查询效率,数据少的时候,红黑树会降级为普通链表)
链表使用Node节点,红黑树使用TreeNode节点
图解
核心数据结构和属性
参数:
static final int TREEIFY_THRESHOLD = 8; | 将链表转换为红黑树的阈值 |
static final int UNTREEIFY_THRESHOLD = 6; | 判断将红黑树转换成链表的阈值 |
node
node是最核心的内部类,他包装了key-value键值对
static class Node<K,V> implements Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
map本身持有一个node型的数组
transient volatile Node<K,V>[] table;
TreeNode
树节点,当链表长度>=8,就会转换成TreeNode红黑树
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
与1.8中HashMap不同
1、并不是直接转换为红黑树,而是把这些节点放在TreeBin对象中,有TreeBin完成对红黑树的包装
2、TreeNode扩展自ConcurrentHashMap中Node类,而并非HashMap中的LinkedHashMap.Entry<K,V>类,也就是说TreeNode带有next指针
TreeBin
负责TreeNode节点。他代替了TreeNode的根节点,也就是说在实际的ConcurrentHashMap数组中,存放的是TreeBin对象,而不是TreeNode对象,另外这个类还带有了读写锁机制。
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root;
volatile TreeNode<K,V> first;
volatile Thread waiter;
volatile int lockState;
// values for lockState
static final int WRITER = 1; // set while holding write lock
static final int WAITER = 2; // set when waiting for write lock
static final int READER = 4; // increment value for setting read lock
特殊的ForWardingNode
一个特殊的Node节点,hash=-1,其中存储nextTable的引用。有table发生扩容的时候,ForWardingNode发挥作用,作为一个占位符放在table中表示当前节点为null或者已经被移动
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
sizeCtl:用来控制table的初始化和扩容操作
private transient volatile int sizeCtl;
负数 | 正在初始化或者扩容操作 |
-1 | 正在初始化 |
-N | 代表有N-1个线程正在进行扩容操作 |
0默认值 | 代表还没有被初始化 |
正数 | 表示初始化大小或者Map中的元素叨叨这个数量是,需要进行扩容了 |
核心方法
/*利用硬件级别的原子操作,获得在i位置上的Node节点
* Unsafe.getObjectVolatile可以直接获取指定内存的数据,
* 保证了每次拿到数据都是最新的*/
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);
}
/*利用CAS操作设置i位置上的Node节点*/
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);
}
/*利用硬件级别的原子操作,设置在i位置上的Node节点
* Unsafe.putObjectVolatile可以直接设定指定内存的数据,
* 保证了其他线程访问这个节点时一定可以看到最新的数据*/
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
构造方法
可以看到,值是简单的属性设置,并没有初始化table,只有在put、computeIfAbsent、conpute、merge等方法的时候,检查table==null,才开始初始化
public ConcurrentHashMap18(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;
}
get操作
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());/*计算hash值*/
/*根据hash值确定节点位置*/
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
/*Node数组中的节点就是要找的节点*/
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
/*eh<0 说明这个节点在树上 调用树的find方法寻找*/
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;
}
put操作
首先根据hash值计算插入点在table中的位置i,如果i位置是空的,还没有存放元素,直接当做链表节点放进去,否则要判断,如果table【i】是红黑树节点,就要按照树的方式插入新的节点,否则把i插入到链表的末尾。
如果是链表,加入元素之后,链表长度大于等于8,就要把链表装换为红黑树。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());/*计算hash值*/
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();/*如果table为空的话,初始化table*/
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
/*Node数组中的元素,这个位置没有值 ,使用CAS操作放进去*/
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;
/*锁Node数组中的元素,这个位置是Hash冲突组成链表的头结点
* 或者是红黑树的根节点*/
synchronized (f) {
if (tabAt(tab, i) == f) {
/*fh>0 说明这个节点是一个链表的节点 不是树的节点*/
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
/*put操作和putIfAbsent操作业务实现*/
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) {
/*达到临界值8 就需要把链表转换为树结构*/
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
/*Map的元素数量+1,并检查是否需要扩容*/
addCount(1L, binCount);
return null;
}
initTable初始化table
在构造函数中并没有初始化ConcurrentHashMap,初始化时发生在向map中插入元素的时候
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
/*小于0表示有其他线程正在进行初始化操作,把当前线程CPU时间让出来。
因为对于table的初始化工作,只能有一个线程在进行。*/
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
/*利用CAS操作把sizectl的值置为-1 表示本线程正在进行初始化*/
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;
/*n右移2位本质上就是n变为n原值的1/4,所以
* sc=0.75*n */
sc = n - (n >>> 2);
}
} finally {
/*将设置成扩容的阈值*/
sizeCtl = sc;
}
break;
}
}
return tab;
}
多线程扩容transfer方法
并发扩容,减少扩容带来的时间影响
1、构建一个是原来容量两倍的newTable
2、数据从table复制到newTable
remove
移除方法基本流程和put方法类似,如果是红黑树,会检查容量是不是<=6,是:红黑树就会转换为链表
treeifyBin
用于将过长的链表转换为TreeBin对象。但是他不是直接转换,而是进行容量判断,如果容量没有达到转化的要求。直接返回。与hashmap
不同的是他并没有把TreeNode直接放入红黑树,而是利用了TreeBin这个笑容起来封装素有的TreeNode
size
在扩容和addcount()的时候,size就已经计算好了,需要size会直接返回,这样节省了时间。(jdk7还要实时计算才能够得到size大小)