HashMap為什麼不是執行緒安全，併發操作Hashmap會帶來什麼問題：
這個問題曾經有一個面試官問過我，當時我天真的以為是讀寫操作併發時存在髒資料的問題，當時面試官不置可否。我後面回來查資料，發現沒有那麼簡單。併發操作HashMap，是有可能帶來死迴圈以及資料丟失的問題的。

情景如下程式碼:

    public class HashMapInfiniteLoop {    
       
        private static HashMap<Integer,String> map = new HashMap<Integer,String>(2，0.75f);    
        public static void main(String[] args) {    
            map.put(5， "C");    
       
            new Thread("Thread1") {    
                public void run() {    
                    map.put(7, "B");    
                    System.out.println(map);    
                };    
            }.start();    
            new Thread("Thread2") {    
                public void run() {    
                    map.put(3, "A);    
                    System.out.println(map);    
                };    
            }.start();          
        }    
    }  
 

其中，map初始化為一個長度為2的陣列，loadFactor=0.75，threshold=2*0.75=1，也就是說當put第二個key的時候，map就需要進行擴容。

考慮這樣一種情況:
先放出transfer的部分程式碼：

    do {  
        Entry<K,V> next = e.next; //假設執行緒一執行到這裡就被排程掛起了  
        int i = indexFor(e.hash, newCapacity);  
        e.next = newTable[i];  
        newTable[i] = e;  
        e = next;  
    } while (e != null);  
 

執行緒1、執行緒2都添加了資料之後，執行緒1執行到transfer()方法的第一行就被排程掛起了，這時執行緒2被排程來執行擴容操作。執行緒2的擴容操作結束之後，執行緒1被排程回來繼續執行，此時由於執行緒2的執行，e已經指向了執行緒2修改之後的反轉連結串列，但是執行緒1並不知道執行緒2已經在它之前做過這些操作了，於是它繼續往下走，此時next=key(7),

然後計算索引。索引計算完之後執行e.next=newTable[i],此時e.next=key(7)。繼續往下走，newTable[i]=e,此時newTable[i]=key(3)，再往下，e=next,此時e指向了key(7),本次迴圈結束。從執行緒二重組連結串列結束，到執行緒1第一輪迴圈結束的變化圖如下:

一切看起來都還沒有什麼問題。然後新一輪迴圈開始

這一輪迴圈我們不需要走完，就能發現問題。

第一句，執行後為:next=null;

第二句，計算索引，還是i

第三句，在這裡就出問題了，這句話執行的是e.next=newTable[i],我們看上圖，newTable[i]指向的是key(3),因此出現連結串列末尾的元素的next指標指向了連結串列頭，迴圈連結串列就出現了。（按道理，HashMap是不存在迴圈連結串列的。）

第四句話，將連結串列頭的元素換成key(7)，而迴圈連結串列依然存在。

第五句，e=null，執行到這迴圈結束，因為e=null了。

整個過程並不會發生明顯的異常。看起來一切安好。順利的完成了rehash，但是悲劇在後面：當我們呼叫get（）這個連結串列中不存在的元素的時候，就會出現死迴圈。go die

一句話總結就是，併發環境下的rehash過程可能會帶來迴圈連結串列，導致死迴圈致使執行緒掛掉。

因此併發環境下，建議使用Java.util.concurrent包中的ConcurrentHashMap以保證執行緒安全。

至於HashTable，它並未使用分段鎖，而是鎖住整個陣列，高併發環境下效率非常的低，會導致大量執行緒等待。
同樣的，Synchronized關鍵字、Lock效能都不如分段鎖實現的ConcurrentHashMap。