一直以來都知道HashMap是執行緒不安全的，但是到底為什麼執行緒不安全，在多執行緒操作情況下什麼時候執行緒不安全？

讓我們先來了解一下HashMap的底層儲存結構，HashMap底層是一個Entry陣列，一旦發生Hash衝突的的時候，HashMap採用拉鍊法解決碰撞衝突，Entry內部的變數：

1. final Object key;  
2. Object value;  
3. Entry next;  
4. int hash;  

        通過Entry內部的next變數可以知道使用的是連結串列，這時候我們可以知道，如果多個執行緒，在某一時刻同時操作HashMap並執行put操作，而有大於兩個key的hash值相同，如圖中a1、a2，這個時候需要解決碰撞衝突，而解決衝突的辦法上面已經說過，對於連結串列的結構在這裡不再贅述，暫且不討論是從連結串列頭部插入還是從尾部初入，這個時候兩個執行緒如果恰好都取到了對應位置的頭結點e1，而最終的結果可想而知，a1、a2兩個資料中勢必會有一個會丟失，如圖所示：

再來看下put方法

1. public Object put(Object obj, Object obj1)  
2.     {  
3.         if(table == EMPTY_TABLE)  
4.             inflateTable(threshold);  
5.         if(obj == null)  
6.             return putForNullKey(obj1);  
7.         int i = hash(obj);  
8.         int j = indexFor(i, table.length);  
9.         for(Entry entry = table[j]; entry != null; entry = entry.next)  
10.         {  
11.             Object obj2;  
12.             if(entry.hash == i && ((obj2 = entry.key) == obj || obj.equals(obj2)))  
13.             {  
14.                 Object obj3 = entry.value;  
15.                 entry.value = obj1;  
16.                 entry.recordAccess(this);  
17.                 return obj3;  
18.             }  
19.         }  
20.         modCount++;  
21.         addEntry(i, obj, obj1, j);  
22.         return null;  
23.     }  

put方法不是同步的，同時呼叫了addEntry方法：

1. void addEntry(int i, Object obj, Object obj1, int j)  
2.     {  
3.         if(size >= threshold && null != table[j])  
4.         {  
5.             resize(2 * table.length);  
6.             i = null == obj ? 0 : hash(obj);  
7.             j = indexFor(i, table.length);  
8.         }  
9.         createEntry(i, obj, obj1, j);  
10.     }  

addEntry方法依然不是同步的，所以導致了執行緒不安全出現傷處問題，其他類似操作不再說明，原始碼一看便知，下面主要說一下另一個非常重要的知識點，同樣也是HashMap非執行緒安全的原因，我們知道在HashMap存在擴容的情況，對應的方法為HashMap中的resize方法：

1. void resize(int i)  
2.     {  
3.         Entry aentry[] = table;  
4.         int j = aentry.length;  
5.         if(j == 1073741824)  
6.         {  
7.             threshold = 2147483647;  
8.             return;  
9.         } else
10.         {  
11.             Entry aentry1[] = new Entry[i];  
12.             transfer(aentry1, initHashSeedAsNeeded(i));  
13.             table = aentry1;  
14.             threshold = (int)Math.min((float)i * loadFactor, 1.073742E+009F);  
15.             return;  
16.         }  
17.     }  

         可以看到擴容方法也不是同步的，通過程式碼我們知道在擴容過程中，會新生成一個新的容量的陣列，然後對原陣列的所有鍵值對重新進行計算和寫入新的陣列，之後指向新生成的陣列。

        當多個執行緒同時檢測到總數量超過門限值的時候就會同時呼叫resize操作，各自生成新的陣列並rehash後賦給該map底層的陣列table，結果最終只有最後一個執行緒生成的新陣列被賦給table變數，其他執行緒的均會丟失。而且當某些執行緒已經完成賦值而其他執行緒剛開始的時候，就會用已經被賦值的table作為原始陣列，這樣也會有問題。