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 原理分析的更多相关文章

  1. ConcurrentHashMap原理分析(1.7与1.8)-put和 get 需要执行两次Hash

    ConcurrentHashMap 与HashMap和Hashtable 最大的不同在于:put和 get 两次Hash到达指定的HashEntry,第一次hash到达Segment,第二次到达Seg ...

  2. [转载] ConcurrentHashMap原理分析

    转载自http://blog.csdn.net/liuzhengkang/article/details/2916620 集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的 ...

  3. Java集合:ConcurrentHashMap原理分析

    集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的支持.比如两个线程需要同时访问一个中间临界区(Queue),比如常会用缓存作为外部文件的副本(HashMap).这篇文章主 ...

  4. 【Java并发编程】1、ConcurrentHashMap原理分析

    集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的支持.比如两个线程需要同时访问一个中间临界区(Queue),比如常会用缓存作为外部文件的副本(HashMap).这篇文章主 ...

  5. Java 中 ConcurrentHashMap 原理分析

    一.Java并发基础 当一个对象或变量可以被多个线程共享的时候,就有可能使得程序的逻辑出现问题. 在一个对象中有一个变量i=0,有两个线程A,B都想对i加1,这个时候便有问题显现出来,关键就是对i加1 ...

  6. ConcurrentHashMap原理分析(二)-扩容

    概述 在上一篇文章中介绍了ConcurrentHashMap的存储结构,以及put和get方法,那本篇文章就介绍一下其扩容原理.其实说到扩容,无非就是新建一个数组,然后把旧的数组中的数据拷贝到新的数组 ...

  7. ConcurrentHashMap原理分析

    当我们享受着jdk带来的便利时同样承受它带来的不幸恶果.通过分析Hashtable就知道,synchronized是针对整张Hash表的,即每次锁住整张表让线程独占,安全的背后是巨大的浪费,而现在的解 ...

  8. ConcurrentHashMap原理分析(1.7与1.8)

    前言 以前写过介绍HashMap的文章,文中提到过HashMap在put的时候,插入的元素超过了容量(由负载因子决定)的范围就会触发扩容操作,就是rehash,这个会重新将原数组的内容重新hash到新 ...

  9. 【转】ConcurrentHashMap原理分析(1.7与1.8)

    https://www.cnblogs.com/study-everyday/p/6430462.html 前言 以前写过介绍HashMap的文章,文中提到过HashMap在put的时候,插入的元素超 ...

随机推荐

  1. java File delete 无法删除文件的原因。

    windows下使用java.io.File.delete()方法删除文件时,返回值为true. 但是本地文件仍然存在,也就是说没有删除成功. 这时候你要检查下你传进来的文件目录格式是否正确. 正确: ...

  2. PHP第一课笔记

    打算以后学习PHP,花3个月时间学会它,自己为自己加油.每天坚持学习,第一天感觉良好,没开始写,所以不敢觉难,在难也学,加油,me!! PHP笔记记录(2014.7.27) ★web开发的介绍 1.动 ...

  3. Ubuntu软件包管理命令全面集锦

    说明:由于图形化界面方法(如Add/Remove... 和Synaptic Package Manageer)比较简单,所以这里主要总结在终端通过命令行方式进行的软件包安装.卸载和删除的方法. 一.U ...

  4. centos挂存储

    #看硬盘有木 fdisk -l   #格式化 parted /dev/sdb mklabel gpt print quit #如果多个分区执行 如果不要么 #mkpart primary 0 4.5T ...

  5. uboot的jumptable_init函数分析

    一.函数说明 函数功能:安装系统函数指针 函数位置:common/exports.c 二.函数分析 void jumptable_init (void) { int i; gd->jt = (v ...

  6. Unity3D Quaternion各属性和函数测试

    Quaternion属性与方法 一,属性: x.y.z就不说了,只看一个eulerAngles,代码如下: public Quaternion rotation = Quaternion.identi ...

  7. ubuntu下配置protobuf

    http://blog.csdn.net/guoyilongedu/article/details/17093811 最近想研究protobuf ,尝试了很多次都没有成功,我用的是ubuntu,在虚拟 ...

  8. couchdb and redis

    http://www.jdon.com/artichect/scalable5.html http://www.dedecms.com/knowledge/data-base/nosql/2012/0 ...

  9. JDBC自动提交和批处理操作

    今天用JDBC与数据库进行交互的时候,报错如下: *************************************************************************** ...

  10. MFC弹出模拟对话框

    Windows对话框分为两类:模态对话框和非模态对话框. 模态对话框是这样的对话框,当它弹出后,本应用程序其他窗口将不再接受用户输入,只有该对话框响应用户输入,在对它进行相应操作退出后,其他窗口才能继 ...