HashMap為什麼執行緒不安全

導致HashMap執行緒不安全的原因可能有兩種：

1、當多個執行緒同時使用put方法新增元素的時候，正巧存在兩個put的key發生了碰撞（根據hash值計算的bucket一樣），那麼根據HashMap的儲存原理，這兩個key會新增多陣列的同一個位置，這樣一定會導致其中一個執行緒put的資料被覆蓋丟失

2、當多個執行緒同時檢測到元素個數超過雜湊表的size*loadFloat的時候,這樣會發生多個執行緒同時對Node陣列進行擴容的操作(java1.8中HashMap使用Node實體來存放內容)，都在重新計算元素位置以及拷貝資料，但最後只能有一個執行緒能成功的將擴容後的陣列賦值給table，也就是說其他執行緒的都會丟失，並且各自執行緒的資料也會丟失。關於hashMap執行緒不安全這一點，《java併發程式設計的藝術》一書中是這麼描述的：“hashMap在併發執行put操作會引起死迴圈，導致CPU利用率接近100%。因為多執行緒會導致HashMap的Node連結串列形成環資料結構，一旦形成環資料結構，Node的next節點永遠不為空，就會在獲取Node時產生死迴圈”。由此可知，HashMap的死迴圈是發生在擴容時。關於hashMap的死迴圈可參看一下文章：

何如使用執行緒安全的HashMap
實現執行緒安全的方式有三種，分別是使用HashTable、Collections.SynchronizeMap、ConcurrentHashMap。

我們先分別來看看三種資料結構的部分原始碼：

hashtable

   public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }

public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { throw new NullPointerException(); } // Makes sure the key is not already in the hashtable. Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> entry = (Entry<K,V>)tab[index]; for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; entry.value = value; return old; } } addEntry(hash, key, value, index); return null; } publicsynchronizedV remove(Object key) { Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> e = (Entry<K,V>)tab[index]; for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { modCount++; if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } count--; V oldValue = e.value; e.value = null; return oldValue; } } return null; }

SynchronizeMap

        public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
        }
        public V remove(Object key) {
            synchronized (mutex) {return m.remove(key);}
        }
        public void putAll(Map<? extends K, ? extends V> map) {
            synchronized (mutex) {m.putAll(map);}
        }
        public void clear() {
            synchronized (mutex) {m.clear();}
        }

通過這部分原始碼可知，HashTable、Collections.SynchronizeMap都是通過對讀寫進行加鎖操作來保證執行緒的安全，一個執行緒進行讀寫資料，其餘執行緒等等，可想而知，效能可想而知。

ConcurrentHashMap

在java8中，ConcurrentHashMap摒棄了Segment,啟用了一種新的演算法實現CAS。關於ConcurrentHashMap工作機制請參考深入淺出ConcurrentHashMap1.8。

下面我們通過一些程式碼來驗證他們之前的執行緒安全以及效率問題：

package com.iresearch.idata.common.util.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;

/**
 * @author: htc
 * @date: Created in 18:18 2017/12/20.
 */
public class ConcurrentMapWithMap {
    private static Map<String, Long> mapWordCounts = new HashMap<>();
    private static ConcurrentMap<String, Long> concurrentMapWordCounts = new ConcurrentHashMap<>();
    public static Logger logger = LoggerFactory.getLogger(ConcurrentMapWithMap.class);
    public static int count = 0;

    public static long mapIncrease(String word) {
        Long oldValue = mapWordCounts.get(word);
        Long newValue = (oldValue == null) ? 1L : oldValue + 1;
        mapWordCounts.put(word, newValue);
        return newValue;
    }


    public static long ConcurrentMapIncrease(String word) {
        Long oldValue, newValue;
        while (true) {
            oldValue = concurrentMapWordCounts.get(word);
            if (oldValue == null) {
                // Add the word firstly, initial the value as 1
                newValue = 1L;
                if (concurrentMapWordCounts.putIfAbsent(word, newValue) == null) {
                    break;
                }
            } else {
                newValue = oldValue + 1;
                if (concurrentMapWordCounts.replace(word, oldValue, newValue)) {
                    break;
                }
            }
        }
        return newValue;
    }

    public static void mapWordCount() throws InterruptedException, ExecutionException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work"));
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work"));
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work"));
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.mapIncrease("work"));
                }
            }
        }).start();
    }

    public static void concurrentWordCount() throws InterruptedException, ExecutionException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work"));
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work"));
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work"));
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                int count = 0;
                while (count++ < 10000) {
                    logger.info("mapIncrease num is " + ConcurrentMapWithMap.ConcurrentMapIncrease("work"));
                }
            }
        }).start();
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ConcurrentMapWithMap.mapWordCount();
        Thread.sleep(10000);
        //多執行緒累加，每次都少於40000，故執行緒不安全
        logger.info("final count map" + ConcurrentMapWithMap.mapWordCounts.get("work"));
        ConcurrentMapWithMap.concurrentWordCount();
        Thread.sleep(10000);
        //多執行緒累加，每次都是40000
        logger.info("final count concurrentMap" + ConcurrentMapWithMap.concurrentMapWordCounts.get("work"));
    }
}