HashMap为什么线程不安全
导致HashMap线程不安全的原因可能有两种:
1、当多个线程同时使用put方法添加元素的时候,正巧存在两个put的key发生了碰撞(根据hash值计算的bucket一样),那么根据HashMap的存储原理,这两个key会添加多数组的同一个位置,这样一定会导致其中一个线程put的数据被覆盖丢失
2、当多个线程同时检测到元素个数超过哈希表的size*loadFloat的时候,这样会发生多个线程同时对Node数组进行扩容的操作(java1.8中HashMap使用Node实体来存放内容),都在重新计算元素位置以及拷贝数据,但最后只能有一个线程能成功的将扩容后的数组赋值给table,也就是说其他线程的都会丢失,并且各自线程的数据也会丢失。关于hashMap线程不安全这一点,《java并发编程的艺术》一书中是这么描述的:“hashMap在并发执行put操作会引起死循环,导致CPU利用率接近100%。因为多线程会导致HashMap的Node链表形成环数据结构,一旦形成环数据结构,Node的next节点永远不为空,就会在获取Node时产生死循环”。由此可知,HashMap的死循环是发生在扩容时。关于hashMap的死循环可参看一下文章:
何如使用线程安全的HashMap
实现线程安全的方式有三种,分别是使用HashTable、Collections.SynchronizeMap、ConcurrentHashMap。
我们先分别来看看三种数据结构的部分源码:
hashtable
public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { throw new NullPointerException(); } // Makes sure the key is not already in the hashtable. Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> entry = (Entry<K,V>)tab[index]; for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; entry.value = value; return old; } } addEntry(hash, key, value, index); return null; } publicsynchronizedV remove(Object key) { Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> e = (Entry<K,V>)tab[index]; for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } count--; V oldValue = e.value; e.value = null; return oldValue; } } return null; }public synchronized V get(Object key) { Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return (V)e.value; } } return null; }
SynchronizeMap
public V put(K key, V value) { synchronized (mutex) {return m.put(key, value);} } public V remove(Object key) { synchronized (mutex) {return m.remove(key);} } public void putAll(Map<? extends K, ? extends V> map) { synchronized (mutex) {m.putAll(map);} } public void clear() { synchronized (mutex) {m.clear();} }
通过这部分源码可知,HashTable、Collections.SynchronizeMap都是通过对读写进行加锁操作来保证线程的安全,一个线程进行读写数据,其余线程等等,可想而知,性能可想而知。
ConcurrentHashMap
在java8中,ConcurrentHashMap摒弃了Segment,启用了一种新的算法实现CAS。关于ConcurrentHashMap工作机制请参考深入浅出ConcurrentHashMap1.8。
下面我们通过一些代码来验证他们之前的线程安全以及效率问题:
package com.iresearch.idata.common.util.demo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ExecutionException; /** * @author: htc * @date: Created in 18:18 2017/12/20. */ public class ConcurrentMapWithMap { private static Map<String, Long> mapWordCounts = new HashMap<>(); private static ConcurrentMap<String, Long> concurrentMapWordCounts = new ConcurrentHashMap<>(); public static Logger logger = LoggerFactory.getLogger(ConcurrentMapWithMap.class); public static int count = 0; public static long mapIncrease(String word) { Long oldValue = mapWordCounts.get(word); Long newValue = (oldValue == null) ? 1L : oldValue + 1; mapWordCounts.put(word, newValue); return newValue; } public static long ConcurrentMapIncrease(String word) { Long oldValue, newValue; while (true) { oldValue = concurrentMapWordCounts.get(word); if (oldValue == null) { // Add the word firstly, initial the value as 1 newValue = 1L; if (concurrentMapWordCounts.putIfAbsent(word, newValue) == null) { break; } } else { newValue = oldValue + 1; if (concurrentMapWordCounts.replace(word, oldValue, newValue)) { break; } } } return newValue; } public static void mapWordCount() throws InterruptedException, ExecutionException { new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work")); } } }).start(); new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work")); } } }).start(); new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work")); } } }).start(); new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work")); } } }).start(); } public static void concurrentWordCount() throws InterruptedException, ExecutionException { new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work")); } } }).start(); new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work")); } } }).start(); new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work")); } } }).start(); new Thread(new Runnable() { @Override public void run() { int count = 0; while (count++ < 10000) { logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work")); } } }).start(); } public static void main(String[] args) throws InterruptedException, ExecutionException { ConcurrentMapWithMap.mapWordCount(); Thread.sleep(10000); //多线程累加,每次都少于40000,故线程不安全 logger.info("final count map" + ConcurrentMapWithMap.mapWordCounts.get("work")); ConcurrentMapWithMap.concurrentWordCount(); Thread.sleep(10000); //多线程累加,每次都是40000 logger.info("final count concurrentMap" + ConcurrentMapWithMap.concurrentMapWordCounts.get("work")); } }