ConcurrentHashMap（并发工具类）

并发工具类

在JDK的并发包里提供了几个非常有用的并发容器和并发工具类。供我们在多线程开发中进行使用。

5.1 ConcurrentHashMap

5.1.1 概述以及基本使用

在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。

案例1：演示HashMap线程不安全

实现步骤

1. 创建一个HashMap集合对象
2. 创建两个线程对象，第一个线程对象向集合中添加元素(1-24),第二个线程对象向集合中添加元素(25-50);
3. 主线程休眠1秒，以便让其他两个线程将数据填装完毕
4. 从集合中找出键和值不相同的数据

测试类

public class HashMapDemo01 {public static void main(String[] args) {// 创建一个HashMap集合对象HashMap<String , String> hashMap = new HashMap<String , String>() ;// 创建两个线程对象,我们本次使用匿名内部类的方式去常见线程对象Thread t1 = new Thread() {@Overridepublic void run() {// 第一个线程对象向集合中添加元素(1-24)for(int x = 1 ; x < 25 ; x++) {hashMap.put(String.valueOf(x) , String.valueOf(x)) ;}}};// 线程t2Thread t2 = new Thread() {@Overridepublic void run() {// 第二个线程对象向集合中添加元素(25-50)for(int x = 25 ; x < 51 ; x++) {hashMap.put(String.valueOf(x) , String.valueOf(x)) ;}}};// 启动线程t1.start();t2.start();System.out.println("----------------------------------------------------------");try {// 主线程休眠2s，以便让其他两个线程将数据填装完毕TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}// 从集合中找出键和值不相同的数据for(int x = 1 ; x < 51 ; x++) {// HashMap中的键就是当前循环变量的x这个数据的字符串表现形式 ， 根据键找到值，然后在进行判断if( !String.valueOf(x).equals( hashMap.get(String.valueOf(x)) ) ) {System.out.println(String.valueOf(x) + ":" + hashMap.get(String.valueOf(x)));}}}}

控制台输出结果

----------------------------------------------------------
5:null

通过控制台的输出结果，我们可以看到在多线程操作HashMap的时候，可能会出现线程安全问题。

注1：需要多次运行才可以看到具体的效果; 可以使用循环将代码进行改造，以便让问题方便的暴露出来！

案例2：演示Hashtable线程安全

测试类

public class HashtableDemo01 {public static void main(String[] args) {// 创建一个Hashtable集合对象Hashtable<String , String> hashtable = new Hashtable<String , String>() ;// 创建两个线程对象,我们本次使用匿名内部类的方式去常见线程对象Thread t1 = new Thread() {@Overridepublic void run() {// 第一个线程对象向集合中添加元素(1-24)for(int x = 1 ; x < 25 ; x++) {hashtable.put(String.valueOf(x) , String.valueOf(x)) ;}}};// 线程t2Thread t2 = new Thread() {@Overridepublic void run() {// 第二个线程对象向集合中添加元素(25-50)for(int x = 25 ; x < 51 ; x++) {hashtable.put(String.valueOf(x) , String.valueOf(x)) ;}}};// 启动线程t1.start();t2.start();System.out.println("----------------------------------------------------------");try {// 主线程休眠2s，以便让其他两个线程将数据填装完毕TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}// 从集合中找出键和值不相同的数据for(int x = 1 ; x < 51 ; x++) {// Hashtable中的键就是当前循环变量的x这个数据的字符串表现形式 ， 根据键找到值，然后在进行判断if( !String.valueOf(x).equals( hashtable.get(String.valueOf(x)) ) ) {System.out.println(String.valueOf(x) + ":" + hashtable.get(String.valueOf(x)));}}}}

不论该程序运行多少次，都不会产生数据问题。因此也就证明Hashtable是线程安全的。

Hashtable保证线程安全的原理：

查看Hashtable的源码

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable {// Entry数组，一个Entry就相当于一个元素private transient Entry<?,?>[] table;// Entry类的定义private static class Entry<K,V> implements Map.Entry<K,V> {final int hash;		// 当前key的hash码值final K key;		// 键V value;			// 值Entry<K,V> next;	// 下一个节点}// 存储数据public synchronized V put(K key, V value){...}// 获取数据public synchronized V get(Object key){...}// 获取长度public synchronized int size(){...}...}

对应的结构如下图所示

Hashtable保证线程安全性的是使用方法全局锁进行实现的。在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable

的同步方法时，会进入阻塞状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

案例3：演示ConcurrentHashMap线程安全

测试类

public class ConcurrentHashMapDemo01 {public static void main(String[] args) {// 创建一个ConcurrentHashMap集合对象ConcurrentHashMap<String , String> concurrentHashMap = new ConcurrentHashMap<String , String>() ;// 创建两个线程对象,我们本次使用匿名内部类的方式去常见线程对象Thread t1 = new Thread() {@Overridepublic void run() {// 第一个线程对象向集合中添加元素(1-24)for(int x = 1 ; x < 25 ; x++) {concurrentHashMap.put(String.valueOf(x) , String.valueOf(x)) ;}}};// 线程t2Thread t2 = new Thread() {@Overridepublic void run() {// 第二个线程对象向集合中添加元素(25-50)for(int x = 25 ; x < 51 ; x++) {concurrentHashMap.put(String.valueOf(x) , String.valueOf(x)) ;}}};// 启动线程t1.start();t2.start();System.out.println("----------------------------------------------------------");try {// 主线程休眠2s，以便让其他两个线程将数据填装完毕TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}// 从集合中找出键和值不相同的数据for(int x = 1 ; x < 51 ; x++) {// concurrentHashMap中的键就是当前循环变量的x这个数据的字符串表现形式 ， 根据键找到值，然后在进行判断if( !String.valueOf(x).equals( concurrentHashMap.get(String.valueOf(x)) ) ) {System.out.println(String.valueOf(x) + ":" + concurrentHashMap.get(String.valueOf(x)));}}}}

不论该程序运行多少次，都不会产生数据问题。因此也就证明ConcurrentHashMap是线程安全的。

5.1.2 源码分析

由于ConcurrentHashMap在jdk1.7和jdk1.8的时候实现原理不太相同，因此需要分别来讲解一下两个不同版本的实现原理。

1) jdk1.7版本

ConcurrentHashMap中的重要成员变量

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable {/*** Segment翻译中文为"段" , 段数组对象*/final Segment<K,V>[] segments;// Segment是一种可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色，将一个大的table分割成多个小的table进行加锁。static final class Segment<K,V> extends ReentrantLock implements Serializable {transient volatile int count;    			// Segment中元素的数量，由volatile修饰，支持内存可见性；transient int modCount;			 			// 对table的大小造成影响的操作的数量（比如put或者remove操作）;transient int threshold;		 			// 扩容阈值;transient volatile HashEntry<K,V>[] table;  // 链表数组，数组中的每一个元素代表了一个链表的头部;final float loadFactor;			 			// 负载因子 }// Segment中的元素是以HashEntry的形式存放在数组中的，其结构与普通HashMap的HashEntry基本一致，不同的是Segment的HashEntry，其value由		     // volatile修饰，以支持内存可见性，即写操作对其他读线程即时可见。static final class HashEntry<K,V> {final int hash;					// 当前节点key对应的哈希码值final K key;					// 存储键volatile V value;				// 存储值volatile HashEntry<K,V> next;	// 下一个节点}}

对应的结构如下图所示

简单来讲，就是ConcurrentHashMap比HashMap多了一次hash过程，第1次hash定位到Segment，第2次hash定位到HashEntry，然后链表搜索找到指定节点。在进行写操作时，只需锁住写

元素所在的Segment即可(这种锁被称为分段锁)，其他Segment无需加锁，从而产生锁竞争的概率大大减小，提高了并发读写的效率。该种实现方式的缺点是hash过程比普通的HashMap要长

(因为需要进行两次hash操作)。

ConcurrentHashMap的put方法源码分析

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable { public V put(K key, V value) {// 定义一个Segment对象Segment<K,V> s;// 如果value的值为空，那么抛出异常if (value == null) throw new NullPointerException();// hash函数获取key的hashCode，然后做了一些处理int hash = hash(key);// 通过key的hashCode定位segmentint j = (hash >>> segmentShift) & segmentMask;// 对定位的Segment进行判断，如果Segment为空，调用ensureSegment进行初始化操作(第一次hash定位)if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null) s = ensureSegment(j);// 调用Segment对象的put方法添加元素return s.put(key, hash, value, false);}// Segment是一种可ReentrantLock，在ConcurrentHashMap里扮演锁的角色，将一个大的table分割成多个小的table进行加锁。static final class Segment<K,V> extends ReentrantLock implements Serializable {// 添加元素final V put(K key, int hash, V value, boolean onlyIfAbsent) {// 尝试对该段进行加锁,如果加锁失败，则调用scanAndLockForPut方法;在该方法中就要进行再次尝试或者进行自旋等待HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);V oldValue;try {// 获取HashEntry数组对象HashEntry<K,V>[] tab = table;// 根据key的hashCode值计算索引(第二次hash定位)int index = (tab.length - 1) & hash;HashEntry<K,V> first = entryAt(tab, index);for (HashEntry<K,V> e = first;;) // 若不为nullif (e != null) {K k;// 判读当前节点的key是否和链表头节点的key相同(依赖于hashCode方法和equals方法) // 如果相同，值进行更新if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {oldValue = e.value;if (!onlyIfAbsent) {e.value = value;++modCount;}break;}e = e.next;} else {  // 若头结点为null// 将新节点添加到链表中if (node != null) node.setNext(first);elsenode = new HashEntry<K,V>(hash, key, value, first);int c = count + 1;// 如果超过阈值，则进行rehash操作if (c > threshold && tab.length < MAXIMUM_CAPACITY)rehash(node);elsesetEntryAt(tab, index, node);++modCount;count = c;oldValue = null;break;}}} finally {unlock();}return oldValue;} 	}}

注：源代码进行简单讲解即可(核心：进行了两次哈希定位以及加锁过程)

2) jdk1.8版本

在JDK1.8中为了进一步优化ConcurrentHashMap的性能，去掉了Segment分段锁的设计。在数据结构方面，则是跟HashMap一样，使用一个哈希表table数组。(数组 + 链表 + 红黑树)

而线程安全方面是结合CAS机制 + 局部锁实现的，减低锁的粒度，提高性能。同时在HashMap的基础上，对哈希表table数组和链表节点的value，next指针等使用volatile来修饰，从而

实现线程可见性。

ConcurrentHashMap中的重要成员变量

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {// Node数组transient volatile Node<K,V>[] table;// Node类的定义static class Node<K,V> implements Map.Entry<K,V> { final int hash;				// 当前key的hashCode值final K key;				// 键volatile V val;				// 值volatile Node<K,V> next;	// 下一个节点}// TreeNode类的定义static final class TreeNode<K,V> extends Node<K,V> {TreeNode<K,V> parent;  // 父节点TreeNode<K,V> left;	   // 左子节点TreeNode<K,V> right;   // 右子节点TreeNode<K,V> prev;    // needed to unlink next upon deletionboolean red;		   // 节点的颜色状态}}

对应的结构如下图

ConcurrentHashMap的put方法源码分析

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {// 添加元素public V put(K key, V value) {return putVal(key, value, false);}// putVal方法定义final V putVal(K key, V value, boolean onlyIfAbsent) {// key为null直接抛出异常if (key == null || value == null) throw new NullPointerException();// 计算key所对应的hashCode值int hash = spread(key.hashCode());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();// 通过hash值计算key在table表中的索引，将其值赋值给变量i,然后根据索引找到对应的Node，如果Node为null,做出处理else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// 新增链表头结点，cas方式添加到哈希表tableif (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) break;                   }else if ((fh = f.hash) == MOVED)tab = helpTransfer(tab, f);else {V oldVal = null;// f为链表头结点，使用synchronized加锁synchronized (f) {if (tabAt(tab, i) == f) {if (fh >= 0) {binCount = 1;for (Node<K,V> e = f;; ++binCount) {K ek;// 节点已经存在，更新value即可if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {oldVal = e.val;if (!onlyIfAbsent)e.val = value;break;}// 该key对应的节点不存在,则新增节点并添加到该链表的末尾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;}}}addCount(1L, binCount);return null;}// CAS算法的核心类private static final sun.misc.Unsafe U;static {try {U = sun.misc.Unsafe.getUnsafe();...} catch (Exception e) {throw new Error(e);}}// 原子获取链表节点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更新或新增链表节点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);}}

简单总结：

1. 如果当前需要put的key对应的链表在哈希表table中还不存在，即还没添加过该key的hash值对应的链表，则调用casTabAt方法，基于CAS机制来实现添加该链表头结点到哈希表

   table中，避免该线程在添加该链表头结的时候，其他线程也在添加的并发问题；如果CAS失败，则进行自旋，通过继续第2步的操作；

2. 如果需要添加的链表已经存在哈希表table中，则通过tabAt方法，基于volatile机制，获取当前最新的链表头结点f，由于f指向的是ConcurrentHashMap的哈希表table的某条

   链表的头结点，故虽然f是临时变量，由于是引用共享的该链表头结点，所以可以使用synchronized关键字来同步多个线程对该链表的访问。在synchronized(f)同步块里面则是与

   HashMap一样遍历该链表，如果该key对应的链表节点已经存在，则更新，否则在链表的末尾新增该key对应的链表节点。