ConcurrentHashMap 原理分析
1 为什么有ConcurrentHashMap
hashmap是非线程安全的,hashtable是线程安全的,但是所有的写和读方法都有synchronized,所以同一时间只有一个线程可以持有对象,多线程情况下锁竞争会比较激烈,严重影响性能。基于这种情况,Doug Lee大师写了一个ConcurrentHashMap类。ConcurrentHashMap是对多线程各种特性深刻理解的经典范例,学习多线程编程不得不学ConcurrentHashMap。
2 特性
ConcurrentHashMap通过锁拆分机制,降低了锁的争用,写时加锁,读时不加锁,降低了锁的持有时间,所以ConcurrentHashMap在高并发情况下的性能得到了大幅提升,ConcurrentHashMap非常适用于读多写少的场景中。
3 原理
3.1 锁拆分
ConcurrentHashMap引入了Segment,通过将键值做hash,数据可以均匀的分布到每个Segment中,每次put,remove等操作的时候,锁的都是当前的Segment,这样就减少了锁的争用。
4 整体类图和关键数据结构
4.1 类图
4.2 数据存储
代码片段1:
ConcurrentHashMap:
final int segmentMask;
final int segmentShift;
final Segment<K,V>[] segments;
代码片段2:
SegMent:
transient volatile int count;
transient int modCount;
transient int threshold;
transient volatile HashEntry<K,V>[] table;
final float loadFactor;
代码片段3:
HashEntry:
final K key;
final int hash;
volatile V value;
final HashEntry<K,V> next;
由上可见,ConcurrentHashMap由Segment数组组成,Segment由table数组组成,每一个table元素都是一个由HashEntry组成的链表结构,hash冲突时会存放到同一个table的链表结构中。键值对保存在HashEntry对象中。
依次插入A B C后,Segment结构示意图:
4.3 Segment特性
transient volatile HashEntry<K,V>[] table;
是volatile的,避免了读取时加锁,volatile特性约束变量的值在本地线程副本中修改后会立即同步到主线程中,保证了其他线程的可见性。
4.3 HashEntry
final K key;
final int hash;
volatile V value;
final HashEntry<K,V> next;
除value外,其他的属性都是final的,value是volatile类型的,都修饰为final表明不允许在此链表结构的中间或者尾部做添加删除操作,每次只允许操作链表的头部。删除元素后,删除元素之后的链表保持不变,删除元素之前的链表重新复制一份,并指向删除元素之后的元素。
例如删除C元素:
注意删除之后原来元素的顺序反转了。
5 关键点:
5.1 put
ConcurrentHashMap:
public V put(K key, V value) {
//不允许value为空
if (value == null)
throw new NullPointerException();
int hash = hash(key.hashCode());
//通过segmentFor(hash)找到找到数据所在的segment
//调用Segment的put方法完成put操作
return segmentFor(hash).put(key, hash, value, false);
}
Segment:
V put(K key, int hash, V value, boolean onlyIfAbsent) {
//put操作需要先获取锁
lock();
try {
int c = count;
//超出界限,进行rehash,table容量扩充1倍。
if (c++ > threshold) // ensure capacity
rehash();
//找到HashEntry的头
HashEntry<K,V>[] tab = table;
int index = hash & (tab.length - 1);
HashEntry<K,V> first = tab[index];
HashEntry<K,V> e = first;
//遍历查找key值是否已经存在
while (e != null && (e.hash != hash || !key.equals(e.key)))
e = e.next;
V oldValue;
if (e != null) {//如果已经存在,则直接替换value
oldValue = e.value;
if (!onlyIfAbsent)
e.value = value;
}
else {//如果不存在,则插入到表头
oldValue = null;
++modCount;//用于记录链表结构化调整,跨段求size会用到
tab[index] = new HashEntry<K,V>(key, hash, first, value);
count = c; // write-volatile
}
return oldValue;
} finally {
unlock();
}
}
5.2 get
V get(Object key, int hash) {
if (count != 0) { // read-volatile
//获取hashentry的头
HashEntry<K,V> e = getFirst(hash);
while (e != null) {//遍历
if (e.hash == hash && key.equals(e.key)) {
V v = e.value;
if (v != null)
return v;
//因为put的value不允许为空,所以如果值为空,说明有其他线程正在构造hashentry对象,发生了指令重排序,所以加锁重新读取一次。
return readValueUnderLock(e); // recheck
}
e = e.next;
}
}
return null;
}
5.3 size
final Segment<K,V>[] segments = this.segments;
long sum = 0;
long check = 0;
int[] mc = new int[segments.length];
// Try a few times to get accurate count. On failure due to
// continuous async changes in table, resort to locking.
for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
check = 0;
sum = 0;
int mcsum = 0;
//遍历,并记录下每个Segment的modCount值
for (int i = 0; i < segments.length; ++i) {
sum += segments[i].count;
mcsum += mc[i] = segments[i].modCount;
}
if (mcsum != 0) {
//再遍历一次,看2次是否相同,如果不相同则再试一次,如果相同则返回size.
for (int i = 0; i < segments.length; ++i) {
check += segments[i].count;
if (mc[i] != segments[i].modCount) {
check = -1; // force retry
break;
}
}
}
if (check == sum)
break;
}
//尝试2次后,如果仍然不相等,则加锁重新读一遍。
if (check != sum) { // Resort to locking all segments
sum = 0;
for (int i = 0; i < segments.length; ++i)
segments[i].lock();
for (int i = 0; i < segments.length; ++i)
sum += segments[i].count;
for (int i = 0; i < segments.length; ++i)
segments[i].unlock();
}
if (sum > Integer.MAX_VALUE)
return Integer.MAX_VALUE;
else
return (int)sum;
6. 思考
6.1 为什么查询可以不加锁?
1)通过HashEntry的不变性降低读操作加锁的需求。
HashEntry的属性key,next,hash都是final类型的,保证只能在头部修改链表,另外value设置为了volatile,保证了写线程写入后,其他读线程都可以看到新值。
非结构化修改:对于非结构化修改,因为value是volatile类型的,所以写线程修改后,读线程立刻可以看到修改后的值。
结构化修改:a)put,由于put插入到链表的表头,链表中的原有节点并没有改变,所以读线程可以正常遍历原有的链表
b)remove ,参见4.3中的图,原有链表也继续保留,所以读线程可以正常遍历链表。
2)用volatile变量协调读写线程的可见性
假设线程M写入count后,线程N读取count。
根据happen-before法则,A happen-before B, C happen-before D, 又根据volatile法则,B happen-bofere C,所以根据传递规则A happen-before D。
从get的代码中看,get会首先读取count,所以读线程能够看到之前对链表做的修改。
6.2 什么时候会造成数据不一致?
线程A先做put操作,线程B后做get操作。
假设put执行到红色注释处,切换到线程B则读到的是线程A put之前的操作,这个概率比较小,并且是允许的,如果要保证严格的一致性,那么只有给读操作加锁。这也印证了每种技术都有其适用的场景那句话,ConcurrentHashMap适用在读多写少的场景下。
V put(K key, int hash, V value, boolean onlyIfAbsent) {
lock();
try {
int c = count;
if (c++ > threshold) // ensure capacity
rehash();
HashEntry<K,V>[] tab = table;
int index = hash & (tab.length - 1);
HashEntry<K,V> first = tab[index];
HashEntry<K,V> e = first;
while (e != null && (e.hash != hash || !key.equals(e.key)))
e = e.next;
//-------------put执行到此处-----------
V oldValue;
if (e != null) {
oldValue = e.value;
if (!onlyIfAbsent)
e.value = value;
}
else {
oldValue = null;
++modCount;
tab[index] = new HashEntry<K,V>(key, hash, first, value);
count = c; // write-volatile
}
return oldValue;
} finally {
unlock();
}
}
7 参考资料:
http://blog.csdn.net/ykdsg/article/details/6257449
http://bhdweb.iteye.com/blog/1722431
http://bhdweb.iteye.com/blog/1722432
http://www.360doc.com/content/12/1105/20/9462341_246041701.shtml
http://www.gznote.com/2014/04/concurrenthashmap%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.html *
http://www.iteye.com/topic/344876
http://andy136566.iteye.com/blog/1070493
ConcurrentHashMap 原理分析的更多相关文章
- ConcurrentHashMap原理分析(1.7与1.8)-put和 get 需要执行两次Hash
ConcurrentHashMap 与HashMap和Hashtable 最大的不同在于:put和 get 两次Hash到达指定的HashEntry,第一次hash到达Segment,第二次到达Seg ...
- [转载] ConcurrentHashMap原理分析
转载自http://blog.csdn.net/liuzhengkang/article/details/2916620 集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的 ...
- Java集合:ConcurrentHashMap原理分析
集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的支持.比如两个线程需要同时访问一个中间临界区(Queue),比如常会用缓存作为外部文件的副本(HashMap).这篇文章主 ...
- 【Java并发编程】1、ConcurrentHashMap原理分析
集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的支持.比如两个线程需要同时访问一个中间临界区(Queue),比如常会用缓存作为外部文件的副本(HashMap).这篇文章主 ...
- Java 中 ConcurrentHashMap 原理分析
一.Java并发基础 当一个对象或变量可以被多个线程共享的时候,就有可能使得程序的逻辑出现问题. 在一个对象中有一个变量i=0,有两个线程A,B都想对i加1,这个时候便有问题显现出来,关键就是对i加1 ...
- ConcurrentHashMap原理分析(二)-扩容
概述 在上一篇文章中介绍了ConcurrentHashMap的存储结构,以及put和get方法,那本篇文章就介绍一下其扩容原理.其实说到扩容,无非就是新建一个数组,然后把旧的数组中的数据拷贝到新的数组 ...
- ConcurrentHashMap原理分析
当我们享受着jdk带来的便利时同样承受它带来的不幸恶果.通过分析Hashtable就知道,synchronized是针对整张Hash表的,即每次锁住整张表让线程独占,安全的背后是巨大的浪费,而现在的解 ...
- ConcurrentHashMap原理分析(1.7与1.8)
前言 以前写过介绍HashMap的文章,文中提到过HashMap在put的时候,插入的元素超过了容量(由负载因子决定)的范围就会触发扩容操作,就是rehash,这个会重新将原数组的内容重新hash到新 ...
- 【转】ConcurrentHashMap原理分析(1.7与1.8)
https://www.cnblogs.com/study-everyday/p/6430462.html 前言 以前写过介绍HashMap的文章,文中提到过HashMap在put的时候,插入的元素超 ...
随机推荐
- java File delete 无法删除文件的原因。
windows下使用java.io.File.delete()方法删除文件时,返回值为true. 但是本地文件仍然存在,也就是说没有删除成功. 这时候你要检查下你传进来的文件目录格式是否正确. 正确: ...
- PHP第一课笔记
打算以后学习PHP,花3个月时间学会它,自己为自己加油.每天坚持学习,第一天感觉良好,没开始写,所以不敢觉难,在难也学,加油,me!! PHP笔记记录(2014.7.27) ★web开发的介绍 1.动 ...
- Ubuntu软件包管理命令全面集锦
说明:由于图形化界面方法(如Add/Remove... 和Synaptic Package Manageer)比较简单,所以这里主要总结在终端通过命令行方式进行的软件包安装.卸载和删除的方法. 一.U ...
- centos挂存储
#看硬盘有木 fdisk -l #格式化 parted /dev/sdb mklabel gpt print quit #如果多个分区执行 如果不要么 #mkpart primary 0 4.5T ...
- uboot的jumptable_init函数分析
一.函数说明 函数功能:安装系统函数指针 函数位置:common/exports.c 二.函数分析 void jumptable_init (void) { int i; gd->jt = (v ...
- Unity3D Quaternion各属性和函数测试
Quaternion属性与方法 一,属性: x.y.z就不说了,只看一个eulerAngles,代码如下: public Quaternion rotation = Quaternion.identi ...
- ubuntu下配置protobuf
http://blog.csdn.net/guoyilongedu/article/details/17093811 最近想研究protobuf ,尝试了很多次都没有成功,我用的是ubuntu,在虚拟 ...
- couchdb and redis
http://www.jdon.com/artichect/scalable5.html http://www.dedecms.com/knowledge/data-base/nosql/2012/0 ...
- JDBC自动提交和批处理操作
今天用JDBC与数据库进行交互的时候,报错如下: *************************************************************************** ...
- MFC弹出模拟对话框
Windows对话框分为两类:模态对话框和非模态对话框. 模态对话框是这样的对话框,当它弹出后,本应用程序其他窗口将不再接受用户输入,只有该对话框响应用户输入,在对它进行相应操作退出后,其他窗口才能继 ...