面试官:HashMap 为什么线程不安全?
前言:我们都知道 HashMap 是线程不安全的,在多线程环境中不建议使用。
但是其线程不安全主要体现在什么地方呢,本文将对该问题进行解密。
jdk1.7 中的 HashMap
在 jdk1.8 中对 HashMap 做了很多优化,这里先分析在 jdk1.7 中的问题,相信大家都知道在 jdk1.7 多线程环境下 HashMap 容易出现死循环,这里我们先用代码来模拟出现死循环的情况:
public class HashMapTest { | |
public static void main(String[] args) { | |
HashMapThread thread0 = new HashMapThread(); | |
HashMapThread thread1 = new HashMapThread(); | |
HashMapThread thread2 = new HashMapThread(); | |
HashMapThread thread3 = new HashMapThread(); | |
HashMapThread thread4 = new HashMapThread(); | |
thread0.start(); | |
thread1.start(); | |
thread2.start(); | |
thread3.start(); | |
thread4.start(); | |
} | |
} | |
class HashMapThread extends Thread { | |
private static AtomicInteger ai = new AtomicInteger(); | |
private static Map<Integer, Integer> map = new HashMap<>(); | |
@Override | |
public void run() { | |
while (ai.get() < 1000000) { | |
map.put(ai.get(), ai.get()); | |
ai.incrementAndGet(); | |
} | |
} | |
} |
上述代码比较简单,就是开多个线程不断进行 put 操作,并且 HashMap 与 AtomicInteger 都是全局共享的。
在多运行几次该代码后,出现如下死循环情形:
其中有几次还会出现数组越界的情况:
这里我们着重分析为什么会出现死循环的情况,通过 jps 和 jstack 命名查看死循环情况,结果如下:
从堆栈信息中可以看到出现死循环的位置,通过该信息可明确知道死循环发生在 HashMap 的扩容函数中,根源在 transfer 函数中,jdk1.7 中 HashMap 的 transfer 函数如下:
void transfer(Entry[] newTable, boolean rehash) { | |
int newCapacity = newTable.length; | |
for (Entry<K,V> e : table) { | |
while(null != e) { | |
Entry<K,V> next = e.next; | |
if (rehash) { | |
e.hash = null == e.key ? 0 : hash(e.key); | |
} | |
int i = indexFor(e.hash, newCapacity); | |
e.next = newTable[i]; | |
newTable[i] = e; | |
e = next; | |
} | |
} | |
} |
总结下该函数的主要作用:
在对 table 进行扩容到 newTable 后,需要将原来数据转移到 newTable 中。
注意 10-12 行代码,这里可以看出在转移元素的过程中,使用的是头插法,也就是链表的顺序会翻转,这里也是形成死循环的关键点。下面进行详细分析。
扩容造成死循环分析过程
前提条件:
这里假设
- hash 算法为简单的用 key mod 链表的大小。
- 最开始 hash 表 size=2,key=3,7,5,则都在 table[1]中。
- 然后进行 resize,使 size 变成 4。
未 resize 前的数据结构如下:
如果在单线程环境下,最后的结果如下:
这里的转移过程,不再进行详述,只要理解 transfer 函数在做什么,其转移过程以及如何对链表进行反转应该不难。
然后在多线程环境下,假设有两个线程 A 和 B 都在进行 put 操作。
线程 A 在执行到 transfer 函数中第 11 行代码处挂起,因为该函数在这里分析的地位非常重要,因此再次贴出来。
此时线程 A 中运行结果如下:
线程 A 挂起后,此时线程 B 正常执行,并完成 resize 操作,结果如下:
这里需要特别注意的点:由于线程 B 已经执行完毕,根据 Java 内存模型,现在 newTable 和 table 中的 Entry 都是主存中最新值:7.next=3,3.next=null。
此时切换到线程 A 上,在线程 A 挂起时内存中值如下:e=3,next=7,newTable[3]=null,代码执行过程如下:
newTable[3]=e ----> newTable[3]=3 | |
e=next ----> e=7 |
此时结果如下:
继续循环:
e=7 | |
next=e.next ----> next=3【从主存中取值】 | |
e.next=newTable[3] ----> e.next=3【从主存中取值】 | |
newTable[3]=e ----> newTable[3]=7 | |
e=next ----> e=3 |
结果如下:
再次进行循环:
e=3 | |
next=e.next ----> next=null | |
e.next=newTable[3] ----> e.next=7 即:3.next=7 | |
newTable[3]=e ----> newTable[3]=3 | |
e=next ----> e=null |
注意此次循环:e.next=7,而在上次循环中 7.next=3,出现环形链表,并且此时 e=null 循环结束。
结果如下:
在后续操作中只要涉及轮询 hashmap 的数据结构,就会在这里发生死循环,造成悲剧。
扩容造成数据丢失分析过程
遵照上述分析过程,初始时:
线程 A 和线程 B 进行 put 操作,同样线程 A 挂起:
此时线程 A 的运行结果如下:
此时线程 B 已获得 CPU 时间片,并完成 resize 操作:
同样注意由于线程 B 执行完成,newTable 和 table 都为最新值:5.next=null。
此时切换到线程 A,在线程 A 挂起时:e=7,next=5,newTable[3]=null。
执行 newtable[i]=e,就将**7 放在了 table[3]**的位置,此时 next=5。接着进行下一次循环:
e=5 | |
next=e.next ----> next=null,从主存中取值 | |
e.next=newTable[1] ----> e.next=5,从主存中取值 | |
newTable[1]=e ----> newTable[1]=5 | |
e=next ----> e=null |
将 5 放置在 table[1]位置,此时 e=null 循环结束,3 元素丢失,并形成环形链表。并在后续操作 hashmap 时造成死循环。
jdk1.8 中 HashMap
在 jdk1.8 中对 HashMap 进行了优化,在发生 hash 碰撞,不再采用头插法方式,而是直接插入链表尾部,因此不会出现环形链表的情况。
但是在多线程的情况下仍然不安全,这里我们看 jdk1.8 中 HashMap 的 put 操作源码:
public V put(K key, V value) {
// 对key的hashCode()做hash
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 步骤①:table为空则创建,触发resize方法
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 步骤②:计算index,并对null做处理
if ((p = tab[i = (n - 1) & hash]) == null) //就是在这里会产生线程安全问题,两个线程同事判断为null,一个线程判断之后挂起,另一个线程继续往下执行,之后,第一个线程唤醒,又继续往下执行,覆盖了之前线程的数据,产生数据丢失
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 步骤③:节点key存在,直接覆盖value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 步骤④:判断该链为红黑树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 步骤⑤:该链为链表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//对于计算出的存储位置下标已经有数据,也就是冲突,转成链表存到下一位
p.next = newNode(hash, key,value,null);
//链表长度大于8转换为红黑树进行处理
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// key已经存在直接覆盖value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 步骤⑥:超过最大容量就扩容,门限原本是初始容量*0.75
if (++size > threshold)
resize(); //扩原来的2倍
afterNodeInsertion(evict);
return null;
}
这是 jdk1.8 中 HashMap 中 put 操作的主函数, 注意第 6 行代码,如果没有 hash 碰撞则会直接插入元素。
如果线程 A 和线程 B 同时进行 put 操作,刚好这两条不同的数据 hash 值一样,并且该位置数据为 null,所以这线程 A、B 都会进入第 6 行代码中。
假设一种情况,线程 A 进入后还未进行数据插入时挂起,而线程 B 正常执行,从而正常插入数据,
然后线程 A 获取 CPU 时间片,此时线程 A 不用再进行 hash 判断了,问题出现:线程 A 会把线程 B 插入的数据给覆盖,发生线程不安全。
这里只是简要分析下 jdk1.8 中 HashMap 出现的线程不安全问题的体现,后续将会对 java 的集合框架进行总结,到时再进行具体分析。
总结
首先 HashMap 是线程不安全的,其主要体现:
- 在 jdk1.7 中,在多线程环境下,扩容时会造成环形链或数据丢失。
- 在 jdk1.8 中,在多线程环境下,会发生数据覆盖的情况。