Java 中 ConcurrentHashMap 原理分析

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

一.Java并发基础

当一个对象或变量可以被多个线程共享的时候,就有可能使得程序的逻辑出现问题。 在一个对象中有一个变量i=0,有两个线程A,B都想对i加1,这个时候便有问题显现出来,关键就是对i加1的这个过程不是原子操作。要想对i进行递增, ***步就是获取i的值,当A获取i的值为0,在A将新的值写入A之前,B也获取了A的值0,然后A写入,i变成1,然后B也写入i,i这个时候依然是1. 当然java的内存模型没有上面这么简单,在Java Memory Model中,Memory分为两类,main memory和working memory,main memory为所有线程共享,working memory中存放的是线程所需要的变量的拷贝(线程要对main memory中的内容进行操作的话,首先需要拷贝到自己的working memory,一般为了速度,working memory一般是在cpu的cache中的)。Volatile的变量在被操作的时候不会产生working memory的拷贝,而是直接操作main memory,当然volatile虽然解决了变量的可见性问题,但没有解决变量操作的原子性的问题,这个还需要synchronized或者CAS相关操作配合进行。

Java 中 ConcurrentHashMap 原理分析

多线程中几个重要的概念:

可见性

也就说假设一个对象中有一个变量i,那么i是保存在main memory中的,当某一个线程要操作i的时候,首先需要从main memory中将i 加载到这个线程的working memory中,这个时候working memory中就有了一个i的拷贝,这个时候此线程对i的修改都在其working memory中,直到其将i从working memory写回到main memory中,新的i的值才能被其他线程所读取。从某个意义上说,可见性保证了各个线程的working memory的数据的一致性。 可见性遵循下面一些规则:

  • 当一个线程运行结束的时候,所有写的变量都会被flush回main memory中。

  • 当一个线程***次读取某个变量的时候,会从main memory中读取***的。

  • volatile的变量会被立刻写到main memory中的,在jsr133中,对volatile的语义进行增强,后面会提到

  • 当一个线程释放锁后,所有的变量的变化都会flush到main memory中,然后一个使用了这个相同的同步锁的进程,将会重新加载所有的使用到的变量,这样就保证了可见性。

原子性

还拿上面的例子来说,原子性就是当某一个线程修改i的值的时候,从取出i到将新的i的值写给i之间不能有其他线程对i进行任何操作。也就是说保证某 个线程对i的操作是原子性的,这样就可以避免数据脏读。 通过锁机制或者CAS(Compare And Set 需要硬件CPU的支持)操作可以保证操作的原子性。

有序性

假设在main memory中存在两个变量i和j,初始值都为0,在某个线程A的代码中依次对i和j进行自增操作(i,j的操作不相互依赖)

i++;
j++;

由于,所以i,j修改操作的顺序可能会被重新排序。那么修改后的ij写到main memory中的时候,顺序可能就不是按照i,j的顺序了,这就是所谓的reordering,在单线程的情况下,当线程A运行结束的后i,j的值都加1 了,在线程自己看来就好像是线程按照代码的顺序进行了运行(这些操作都是基于as-if-serial语义的),即使在实际运行过程中,i,j的自增可能 被重新排序了,当然计算机也不能帮你乱排序,存在上下逻辑关联的运行顺序肯定还是不会变的。但是在多线程环境下,问题就不一样了,比如另一个线程B的代码 如下

  1. if(j==1) { 
  2.     System.out.println(i); 

按照我们的思维方式,当j为1的时候那么i肯定也是1,因为代码中i在j之前就自增了,但实际的情况有可能当j为1的时候i还是为0。这就是 reordering产生的不好的后果,所以我们在某些时候为了避免这样的问题需要一些必要的策略,以保证多个线程一起工作的时候也存在一定的次序。 JMM提供了happens-before 的排序策略。这样我们可以得到多线程环境下的as-if-serial语义。 这里不对happens-before进行详细解释了,详细的请看这里http://www.ibm.com/developerworks/cn /java/j-jtp03304/,这里主要讲一下volatile在新的java内存模型下的变化,在jsr133之前,下面的代码可能会出现问题

  1. Map configOptions; 
  2. char[] configText; 
  3. volatile boolean initialized = false
  4. // In Thread A 
  5. configOptions = new HashMap(); 
  6. configText = readConfigFile(fileName); 
  7. processConfigOptions(configText, configOptions); 
  8. initialized = true
  9. // In Thread B 
  10. while (!initialized) 
  11.   sleep(); 
  12. // use configOptions 

jsr133之前,虽然对 volatile 变量的读和写不能与对其他 volatile 变量的读和写一起重新排序,但是它们仍然可以与对 nonvolatile 变量的读写一起重新排序,所以上面的Thread A的操作,就可能initialized变成true的时候,而configOptions还没有被初始化,所以initialized先于 configOptions被线程B看到,就产生问题了。

JSR 133 Expert Group 决定让 volatile 读写不能与其他内存操作一起重新排序,新的内存模型下,如果当线程 A 写入 volatile 变量 V 而线程 B 读取 V 时,那么在写入 V 时,A 可见的所有变量值现在都可以保证对 B 是可见的。

结果就是作用更大的 volatile 语义,代价是访问 volatile 字段时会对性能产生更大的影响。这一点在ConcurrentHashMap中的统计某个segment元素个数的count变量中使用到了。

二.线程安全的HashMap

什么时候我们需要使用线程安全的hashmap呢,比如一个hashmap在运行的时候只有读操作,那么很明显不会有问题,但是当涉及到同时有改变 也有读的时候,就要考虑线程安全问题了,在不考虑性能问题的时候,我们的解决方案有Hashtable或者 Collections.synchronizedMap(hashMap),这两种方式基本都是对整个hash表结构做锁定操作的,这样在锁表的期间, 别的线程就需要等待了,无疑性能不高。

三.ConcurrentHashMap实现原理

数据结构 ConcurrentHashMap的目标是实现支持高并发、高吞吐量的线程安全的HashMap。当然不能直接对整个hashtable加锁,所以在ConcurrentHashMap中,数据的组织结构和HashMap有所区别。

一个ConcurrentHashMap由多个segment组成,每一个segment都包含了一个HashEntry数组的 hashtable, 每一个segment包含了对自己的hashtable的操作,比如get,put,replace等操作,这些操作发生的时候,对自己的 hashtable进行锁定。由于每一个segment写操作只锁定自己的hashtable,所以可能存在多个线程同时写的情况,性能无疑好于只有一个 hashtable锁定的情况。

源码分析 在ConcurrentHashMap的remove,put操作还是比较简单的,都是将remove或者put操作交给key所对应的segment去做的,所以当几个操作不在同一个segment的时候就可以并发的进行。

  1. public V remove(Object key) { 
  2.     int hash = hash(key.hashCode()); 
  3.         return segmentFor(hash).remove(key, hash, null); 
  4.     } 

而segment中的remove操作除了加锁之外和HashMap中的remove操作基本无异。

 

  1. /** 
  2.          * Remove; match on key only if value null, else match both. 
  3.          */ 
  4.         V remove(Object key, int hash, Object value) { 
  5.             lock(); 
  6.             try { 
  7.                 int c = count - 1
  8.                 HashEntry<K,V>[] tab = table; 
  9.                 int index = hash & (tab.length - 1); 
  10.                 HashEntry<K,V> first = tab[index]; 
  11.                 HashEntry<K,V> e = first; 
  12.                 while (e != null && (e.hash != hash || !key.equals(e.key))) 
  13.                     e = e.next; 
  14.  
  15.                 V oldValue = null
  16.                 if (e != null) { 
  17.                     V v = e.value; 
  18.                     if (value == null || value.equals(v)) { 
  19.                         oldValue = v; 
  20.                         // All entries following removed node can stay 
  21.                         // in list, but all preceding ones need to be 
  22.                         // cloned. 
  23.                         ++modCount; 
  24.                         HashEntry<K,V> newFirst = e.next; 
  25.                         for (HashEntry<K,V> p = first; p != e; p = p.next) 
  26.                             newFirst = new HashEntry<K,V>(p.key, p.hash, 
  27.                                                           newFirst, p.value); 
  28.                         tab[index] = newFirst; 
  29.                         count = c; // write-volatile 
  30.                     } 
  31.                 } 
  32.                 return oldValue; 
  33.             } finally { 
  34.                 unlock(); 
  35.             } 
  36.         } 

上面的代码中关于volatile类型的变量count值得一提,这里充分利用了Java 5中对volatile语义的增强,count = c的操作必须在modCount,table等操作的后面,这样才能保证这些变量操作的可见性。 Segment类继承于ReentrantLock,主要是为了使用ReentrantLock的锁,ReentrantLock的实现比 synchronized在多个线程争用下的总体开销小。 put操作和remove操作类似。

接下来我们来看下get操作。

 

  1. public V get(Object key) { 
  2.         int hash = hash(key.hashCode()); 
  3.         return segmentFor(hash).get(key, hash); 
  4.     } 
  5.  
  6. 也是使用了对应的segment的get 
  7.  
  8. V get(Object key, int hash) { 
  9.             if (count != 0) { // read-volatile 
  10.                 HashEntry<K,V> e = getFirst(hash); 
  11.                 while (e != null) { 
  12.                     if (e.hash == hash && key.equals(e.key)) { 
  13.                         V v = e.value; 
  14.                         if (v != null
  15.                             return v; 
  16.                         return readValueUnderLock(e); // recheck 
  17.                     } 
  18.                     e = e.next; 
  19.                 } 
  20.             } 
  21.             return null
  22.         } 

上面的代码中,一开始就对volatile变量count进行了读取比较,这个还是java5对volatile语义增强的作用,这样就可以获取变 量的可见性。所以count != 0之后,我们可以认为对应的hashtable是***的,当然由于读取的时候没有加锁,在get的过程中,可能会有更新。当发现根据key去找元素的时 候,但发现找得的key对应的value为null,这个时候可能会有其他线程正在对这个元素进行写操作,所以需要在使用锁的情况下在读取一下 value,以确保最终的值。

其他相关涉及读取的操作也都类似。

责任编辑:王雪燕 来源: geeklu的博客
相关推荐

2023-10-10 08:39:25

Java 7Java 8

2020-09-22 12:00:23

Javahashmap高并发

2016-09-12 14:33:20

javaHashMap

2020-10-26 07:02:11

ConcurrentH存储

2009-03-26 13:43:59

实现Order ByMySQL

2023-02-07 09:17:19

Java注解原理

2009-04-02 10:23:13

实现JoinMySQL

2023-01-30 22:43:39

DubboZooKeeper

2017-04-12 10:02:21

Java阻塞队列原理分析

2011-06-16 08:43:39

JAVAJIN

2021-04-27 11:15:51

Java 8ConcurrentHBUG

2009-07-24 13:54:39

MVVM模式

2009-02-27 08:56:30

IIS.Net原理分析

2024-01-30 07:36:51

Javalocks

2023-11-29 16:21:30

Kubernetes服务注册

2021-08-18 16:05:40

鸿蒙HarmonyOS应用

2012-04-11 15:41:48

JavaNIO

2020-05-14 10:47:13

Android Java 8

2018-10-31 15:54:47

Java线程池源码

2021-10-12 17:19:17

Random局限性变量
点赞
收藏

51CTO技术栈公众号