HashMap为什么是线程不安全的？

怼烎@ 2021-09-11 06:16 386阅读 0赞

一直以来只是知道HashMap是线程不安全的，但是到底HashMap为什么线程不安全，多线程并发的时候在什么情况下可能出现问题？

HashMap底层是一个Entry数组，当发生hash冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。

javadoc中关于hashmap的一段描述如下：

**此实现不是同步的。**如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它*必须* 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 [`Collections.synchronizedMap`][Collections.synchronizedMap] 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示：

Map m = Collections.synchronizedMap(new HashMap(...));

1、

**\[java\]**  [view plain][]   [copy][view plain]

1.  **void** addEntry(**int** hash, K key, V value, **int** bucketIndex) \{  
2.      Entry<K,V> e = table\[bucketIndex\];  
3.          table\[bucketIndex\] = **new** Entry<K,V>(hash, key, value, e);  
4.          **if** (size++ >= threshold)  
5.              resize(2 \* table.length);  
6.      \}

在hashmap做put操作的时候会调用到以上的方法。现在假如A线程和B线程同时对同一个数组位置调用addEntry，两个线程会同时得到现在的头结点，然后A写入新的头结点之后，B也写入新的头结点，那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失

2、

**\[java\]**  [view plain][]   [copy][view plain]

1.  **final** Entry<K,V> removeEntryForKey(Object key) \{  
2.          **int** hash = (key == **null**) ? 0 : hash(key.hashCode());  
3.          **int** i = indexFor(hash, table.length);  
4.          Entry<K,V> prev = table\[i\];  
5.          Entry<K,V> e = prev;  
6.    
7.          **while** (e != **null**) \{  
8.              Entry<K,V> next = e.next;  
9.              Object k;  
10.             **if** (e.hash == hash &&  
11.                 ((k = e.key) == key || (key != **null** && key.equals(k)))) \{  
12.                 modCount++;  
13.                 size--;  
14.                 **if** (prev == e)  
15.                     table\[i\] = next;  
16.                 **else**  
17.                     prev.next = next;  
18.                 e.recordRemoval(**this**);  
19.                 **return** e;  
20.             \}  
21.             prev = e;  
22.             e = next;  
23.         \}  
24.   
25.         **return** e;  
26.     \}

删除键值对的代码如上：

当多个线程同时操作同一个数组位置的时候，也都会先取得现在状态下该位置存储的头结点，然后各自去进行计算操作，之后再把结果写会到该数组位置去，其实写回的时候可能其他的线程已经就把这个位置给修改过了，就会覆盖其他线程的修改

3、addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操作，代码如下：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **void** resize(**int** newCapacity) \{  
2.          Entry\[\] oldTable = table;  
3.          **int** oldCapacity = oldTable.length;  
4.          **if** (oldCapacity == MAXIMUM\_CAPACITY) \{  
5.              threshold = Integer.MAX\_VALUE;  
6.              **return**;  
7.          \}  
8.    
9.          Entry\[\] newTable = **new** Entry\[newCapacity\];  
10.         transfer(newTable);  
11.         table = newTable;  
12.         threshold = (**int**)(newCapacity \* loadFactor);  
13.     \}

这个操作会新生成一个新的容量的数组，然后对原数组的所有键值对重新进行计算和写入新的数组，之后指向新生成的数组。

当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操作，各自生成新的数组并rehash后赋给该map底层的数组table，结果最终只有最后一个线程生成的新数组被赋给table变量，其他线程的均会丢失。而且当某些线程已经完成赋值而其他线程刚开始的时候，就会用已经被赋值的table作为原始数组，这样也会有问题。

[Collections.synchronizedMap]: http://www.ostools.net/uploads/apidocs/jdk-zh/java/util/Collections.html#synchronizedMap%28java.util.Map%29
[view plain]: http://blog.csdn.net/mydreamongo/article/details/8960667#