ConcurrentHashMap源码分析_JDK1.8版本
在jdk1.8中主要做了2方面的改进
改进一:取消segments字段,直接采用transient volatile HashEntry<K,V>[] table保存数据,采用table数组元素作为锁,从而实现了对每一行数据进行加锁,进一步减少并发冲突的概率。
改进二:将原先table数组+单向链表的数据结构,变更为table数组+单向链表+红黑树的结构。对于hash表来说,最核心的能力在于将key hash之后能均匀的分布在数组中。如果hash之后散列的很均匀,那么table数组中的每个队列长度主要为0或者1。但实际情况并非总是如此理想,虽然ConcurrentHashMap类默认的加载因子为0.75,但是在数据量过大或者运气不佳的情况下,还是会存在一些队列长度过长的情况,如果还是采用单向列表方式,那么查询某个节点的时间复杂度为O(n);因此,对于个数超过8(默认值)的列表,jdk1.8中采用了红黑树的结构,那么查询的时间复杂度可以降低到O(logN),可以改进性能。
JDK1.6版本
ConcurrentHashMap结构
在JDK1.6中,ConcurrentHashMap将数据分成一段一段存储,给每一段数据配一把锁,当一个线程获得锁互斥访问一个段数据时,其他段的数据也可被其他线程访问;每个Segment拥有一把可重入锁,因此ConcurrentHashMap的分段锁数目即为Segment数组长度。ConcurrentHashMap结构:每一个segment都是一个HashEntry<K,V>[] table
, table中的每一个元素本质上都是一个HashEntry的单向队列(单向链表实现)。每一个segment都是一个HashEntry<K,V>[] table
, table中的每一个元素本质上都是一个HashEntry的单向队列。
锁分离实现
当一个线程访问Node/键值对数据时,必须获得与它对应的segment锁,其他线程可以访问其他Segment中的数据(锁分离);
ConcurrentHashMap声明
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable
无锁算法:CAS
乐观锁与悲观锁
悲观锁比如synchronized锁,为确保其他线程不会干扰当前线程工作,因此挂起其他需要锁的线程,等待持有锁的线程释放;
乐观锁总是假设没有冲突发生去做操作,如果检测到冲突就失败重试,知道成功为止;
CAS算法
CAS(Compare And Swap):CAS算法包含三个参数CAS(V, E, N),判断预期值E和内存旧值是否相同(Compare),如果相等用新值N覆盖旧值V(Swap),否则失败;
当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,其他线程失败(失败线程不会被阻塞,而是被告知“失败”,可以继续尝试);
CAS在硬件层面可以被编译为机器指令执行,因此性能高于基于锁占有方式实现线程安全;
ConcurrentHashMap结构图示
与JDK1.6对比
JDK 1.8取消类segments
字段,直接用table数组存储键值对,JDK1.6中每个bucket中键值对组织方式是单向链表,查找复杂度是O(n)
,JDK1.8中当链表长度超过TREEIFY_THRESHOLD
时,链表转换为红黑树,查询复杂度可以降低到O(log n),改进性能;
锁分离
JDK1.8中,一个线程每次对一个桶(链表 or 红黑树)进行加锁,其他线程仍然可以访问其他桶;
线程安全
ConcurrentHashMap底层数据结构与HashMap相同,仍然采用table数组+链表+红黑树结构;
一个线程进行put/remove操作时,对桶(链表 or 红黑树)加上synchronized独占锁;
ConcurrentHashMap采用CAS算法保证线程安全;
ConcurrentHashMap基本数据结构
transient volatile Node<K,V>[] table
:键值对桶数组private transient volatile Node<K,V>[] nextTable
: rehash扩容时用到的新键值对数组private transient volatile long baseCount
:<span id = "jump1"></span>记录当前键值对总数,通过CAS更新,对所有线程可见private transient volatile int sizeCtl
sizeCtl
表示键值对总数阈值,通过CAS更新, 对所有线程可见当
sizeCtl
< 0时,表示多个线程在等待扩容;当
sizeCtl
= 0时,默认值;当
sizeCtl
> 0时,表示扩容的阈值;
private transient volatile int cellBusy
:自旋锁;private transient volatile CounterCell[] counterCells
: counter cell表,长度总为2的幂次;static class Segment<K,V>
:在JDK1.8中,Segment类仅仅在序列化和反序列化时发挥作用;
// 视图
private transient KeySetView<K,V> keySet
private transient ValuesView<K,V> values
private transient EntrySetView<K,V> entrySet
描述键值对:Node<K, V>
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
// 键值对的value和next均为volatile类型
volatile V val;
volatile Node<K,V> next;
...
}
ConcurrentHashMap重要方法分析
构造函数
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
public ConcurrentHashMap(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;
}
该构造器会根据输入的initialCapacity
确定一个 >= initialCapacity的最小2的次幂;
concurrentLevel
:在JDK1.8之前本质是ConcurrentHashMap分段锁总数,表示同时更新ConcurrentHashMap且不产生锁竞争的最大线程数;在JDK1.8中,仅在构造器中确保初始容量>=concurrentLevel,为兼容旧版本而保留;
添加/更新键值对:putVal
putVal方法分析
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;
// 不断CAS探测,如果其他线程正在修改tab,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();
/**
* CAS探测空桶
* 计算key所在bucket表中数组索引: i = (n - 1) & hash)
*/
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// CAS添加新键值对
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 检测到tab[i]桶正在进行rehash,
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;
}
}
}
// 更新baseCount
addCount(1L, binCount);
return null;
}
synchronized (f) {}
操作通过对桶的首元素 = 链表表头 Or 红黑树根节点加锁,从而实现对整个桶进行加锁,有锁分离思想的体现;
获取键值对: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;
}
get方法通过CAS保证键值对的原子性,当tab[i]被锁住,CAS失败并不断重试,保证get不会出错;
删除键值对:remove
扩容机制
transfer
当baseCount超过sizeCtl,将table中所有bin内的键值对拷贝到nextTable;
待补充;
helpTransfer
待补充;
table原子操作方法
获取tab[i]: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方法原子读取table[i];调用Unsafe
对象的getObjectVolatile
方法获取tab[i],由于对volatile写操作happen-before于volatile读操作,因此其他线程对table的修改均对get读取可见;((long)i << ASHIFT) + ABASE)
计算i元素的地址
CAS算法更新键值对: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);
}
casTabAt通过compareAndSwapObject方法比较tabp[i]和v是否相等,相等就用c更新tab[i];
更新键值对:setTabAt
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
仅在synchronized同步块中被调用,更新键值对;
CAS更新baseCount
addCountaddCount
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// s = b + x,完成baseCount++操作;
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))) {
// 多线程CAS发生失败时执行
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// 当更新后的键值对总数baseCount >= 阈值sizeCtl时,进行rehash
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
// sc < 0 表示其他线程已经在rehash
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 其他线程的rehash操作已经完成,当前线程可以进行rehash
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// sc >= 0 表示只有当前线程在进行rehash操作,调用辅助扩容方法transfer
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
addCount负责对baseCount + 1操作,CounterCell是Striped64类型,否则应对高并发问题;
fullAddCount
待补充;
ConcurrentHashMap源码分析_JDK1.8版本的更多相关文章
- ConcurrentHashMap源码分析(JDK8版本<转载>)
注:本文源码是JDK8的版本,与之前的版本有较大差异 转载地址:http://blog.csdn.net/u010723709/article/details/48007881 ConcurrentH ...
- ConcurrentHashMap 源码分析
ConcurrentHashMap 源码分析 1. 前言 终于到这个类了,其实在前面很过很多次这个类,因为这个类代码量比较大,并且涉及到并发的问题,还有一点就是这个代码有些真的晦涩,不好懂.前前 ...
- 死磕 java集合之ConcurrentHashMap源码分析(三)
本章接着上两章,链接直达: 死磕 java集合之ConcurrentHashMap源码分析(一) 死磕 java集合之ConcurrentHashMap源码分析(二) 删除元素 删除元素跟添加元素一样 ...
- 并发-ConcurrentHashMap源码分析
ConcurrentHashMap 参考: http://www.cnblogs.com/chengxiao/p/6842045.html https://my.oschina.net/hosee/b ...
- Hashtable、ConcurrentHashMap源码分析
Hashtable.ConcurrentHashMap源码分析 为什么把这两个数据结构对比分析呢,相信大家都明白.首先二者都是线程安全的,但是二者保证线程安全的方式却是不同的.废话不多说了,从源码的角 ...
- ConcurrentHashMap源码分析(一)
本篇博客的目录: 前言 一:ConcurrentHashMap简介 二:ConcurrentHashMap的内部实现 三:总结 前言:HashMap很多人都熟悉吧,它是我们平时编程中高频率出现的一种集 ...
- [阿里DIEN] 深度兴趣进化网络源码分析 之 Keras版本
[阿里DIEN] 深度兴趣进化网络源码分析 之 Keras版本 目录 [阿里DIEN] 深度兴趣进化网络源码分析 之 Keras版本 0x00 摘要 0x01 背景 1.1 代码进化 1.2 Deep ...
- ConcurrentHashMap源码分析(1.8)
0.说明 1.ConcurrentHashMap跟HashMap,HashTable的对比 2.ConcurrentHashMap原理概览 3.ConcurrentHashMap几个重要概念 4.Co ...
- java基础系列之ConcurrentHashMap源码分析(基于jdk1.8)
1.前提 在阅读这篇博客之前,希望你对HashMap已经是有所理解的,否则可以参考这篇博客: jdk1.8源码分析-hashMap:另外你对java的cas操作也是有一定了解的,因为在这个类中大量使用 ...
随机推荐
- js实现禁止右键 禁止f12 查看源代码
document.oncontextmenu = function () { return false; }; document.onkeydown = function () { if (windo ...
- js-权威指南-Web套接字
HTTP是一种无状态的协议,,由客户端请求和服务端响应组成.HTTP实际上是比较特殊的网络协议. 大多数基于因特网的网络连接通常包含长连接和基于TCP套接字的双向消息交换.让不信任的客户端脚本访问底层 ...
- eclipse java web项目经常自动调试进入debug模式
今天在运行Javaweb项目时,程序运行运行着就自动调试进入ThreadpoolExecutor,看着非常影响心情.最后在网上搜解决方法最后找到原因,解决方法如下. Window——>Prefe ...
- 关于animation的一些简单基础和使用方法记载
第一次写博客,只是单纯的想把我自己的一些心得和使用过的css3的animation的一些方法记录和总结,方便下次使用,我写的这些都是刚入门适合做一些简单的动画动作,过于复杂的还有待发掘或者使用别的方法 ...
- innerHTML在ie9有部分无法添加
在高版本的浏览器,innerHTML就如正常时候,里面可以套任何字符串,但是在ie9下,innerHTML不能是table ,tr td等标签字符串,解决方法如下: 在table添加一个tr var ...
- 解读 --- 基于微软企业商务应用平台 (Microsoft Dynamics 365) 之上的人工智能 (AI) 解决方案
9月25日微软今年一年一度的Ignite 2017在佛罗里达州奥兰多市还是如期开幕了.为啥这么说?因为9月初五级飓风厄玛(Hurricane Irma) 在佛罗里达州登陆,在当地造成了挺大的麻烦.在这 ...
- Maven学习(二)使用命令创建maven项目
创建maven项目 手动 严格参照约定目录结构,我们开始手动新增文件夹 命令方式 project项目 我们也可以使用maven自动生成目录: mvn archetype:generate -Dgrou ...
- 分享一个 jsPDF的简单使用以及中文编码问题的解决
后台一个下载文件中内容国际化问题的坑甩到了前端 前端自己匹配,自己处理国际化,生成文件下载 jsPDF-AutoTable 挺靠谱 中文乱码, 还是好人多啊 解决方式如下文章 jsPDF的简单使 ...
- 对Controller的单元测试
在ASP.NET MVC项目的Controller中存在逻辑代码,也需要单元测试.查阅到的资料上,有说ASP.NET MVC框架在设计时便考虑到了满足可测试性,所以相对aspx.Winform来说针对 ...
- MVC与单元测试实践之健身网站(一)-项目概述
前不久刚刚通过租房网站的开发学习了MVC,并随后学习了单元测试相关的基础,现在开始健身网站的开发,该项目将结合MVC与单元测试,在开发实践过程中,趁热打铁,巩固并运用之前的内容. 一 健身网站功能描述 ...