在平時開發中，我們經常採用HashMap來作為本地快取的一種實現方式，將一些如系統變數等資料量比較少的引數儲存在HashMap中，並將其作為單例類的一個屬性。在系統執行中，使用到這些快取資料，都可以直接從該單例中獲取該屬性集合。但是，最近發現，HashMap並不是執行緒安全的，如果你的單例類沒有做程式碼同步或物件鎖的控制，就可能出現異常。

首先看下在多執行緒的訪問下，非現場安全的HashMap的表現如何，在網上看了一些資料，自己也做了一下測試：

{
 2    
 3    public static final HashMap<String, String> firstHashMap=new

 HashMap<String, String>();
 4    
 5    public static void main(String[] args) throws InterruptedException {
 6        
 7        //執行緒一 8        Thread t1=new Thread(){
 9            public void run() {
10                for(int i=0;i<25;i++){
11                    firstHashMap.put(String.valueOf(i), String.valueOf(i));
12

                }
13            }
14        };
15        
16        //執行緒二17        Thread t2=new Thread(){
18            public void run() {
19                for(int j=25;j<50;j++){
20                    firstHashMap.put(String.valueOf(j), String.valueOf(j));
21                }
22            }
23        };
24

        
25        t1.start();
26        t2.start();
27        
28        //主執行緒休眠1秒鐘，以便t1和t2兩個執行緒將firstHashMap填裝完畢。29        Thread.currentThread().sleep(1000);
30        
31        for(int l=0;l<50;l++){
32            //如果key和value不同，說明在兩個執行緒put的過程中出現異常。33            if(!String.valueOf(l).equals(firstHashMap.get(String.valueOf(l)))){
34                System.err.println(String.valueOf(l)+":"+firstHashMap.get(String.valueOf(l)));
35            }
36        }
37        
38    }
39
40}

{
 2    if (key == null)
 3        return putForNullKey(value);
 4        int hash = hash(key.hashCode());
 5        int i = indexFor(hash, table.length);
 6        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
 7            Object k;
 8            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
 9                V oldValue = e.value;
10                e.value = value;
11                e.recordAccess(this);
12                return oldValue;
13            }
14        }
15
16        modCount++;
17        addEntry(hash, key, value, i);
18        return null;
19    }

{
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    }

{
 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作為原始陣列，這樣也會有問題。