HashMap為何執行緒不安全

只有JAVA8的環境，就看8的吧

歡迎評論，如果寫的不好，我優化

首先來個試驗：

try {
            List<Integer> list1 = new ArrayList();
            HashMap<Integer,Integer> map = new HashMap<>();
            for (int i = 0; i < 1000; i++) {
                list1.add(i);
            }
            list1.parallelStream().forEach(
                    i -> {
                        try {
                            map.put(i,i);
                        }catch (Exception e){
                            System.out.println(e);
                        }
                    }
            );
            System.out.println("size of map:" + map.size());
        } catch (Exception e) {
            System.out.println(e);
        }

size of map:932

少了好幾個值，確實不安全

我們來看看內部實現，點開HashMap類：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

JAVA8開始，HashMap內部使用的是一個Node物件，所以你塞進去的每個K、V鍵值對都會生成一個Node物件，並且Node物件有next可以指向下一個物件，串聯起來，這樣就避免了使用List去管理同一個hash桶中的多個物件；

我們來看看put方法,往下點兩層到putVal：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

哦呦，眼花繚亂
來，耐著性子一點點看

if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

table為null或者長度為0，就調resize初始化一下，待會我們再來看resize；
併發下，可能初始化多遍；

if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

用&符號取模後發現這個hash槽位是空的，那直接把這個node放到這個槽位即可；
併發下，兩個執行緒的值可能相互覆蓋，最終只保留到了一個值；
這裡順便提一下取模操作，n是hash捅目前的長度，二進位制下一定是100000，減1後就是11111,和當前key值的hash值做&就是hash對n取餘；用這種方式的目的就是效率高；

來看看這個槽位不是null的時候咋搞：

else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }

使用了一個Node<K,V> e，p就是當前槽位的Node
第一個if：如果傳進來的key值和當前槽位的key值相等，e指向當前槽位的Node
第二個else if：如果是個TreeNode，這個是基於紅黑樹的Node，這個時候就不是串聯了，需要呼叫putTreeVal來把當前的key和value掛上去，紅黑樹node我們就不深入了，有興趣自己去看；一般使用好像並不會插入TreeNode；TreeNode是給LinkedHashMap使用的；
第三個else：過來的key值和當前槽位key值不一樣，只是恰巧八字比較合，hash衝突了，大家在一個槽位，那樣就一個個node.next遍歷，掛到最後面去；
最後：計算些其他有用的變數，比如size要和threshold比較，超過就要擴容（threshold=陣列長度*loadFactor控制最大元素數量，loadFactor預設0.75）

上述各個變數都沒有鎖，判空、賦值所有的運算都不安全，多執行緒操作各個環節都可能出問題

然後我們來看看擴容：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

很長~~~~~~~~~~~~~~~~~
返回的就是一個Node<K,V>[]陣列
擴容提是通過newCap = oldCap << 1和newThr = oldThr << 1; // double threshold來實現容量計算的，擴大兩倍；其中cap控制陣列長度，threshold控制最大的Node數量
然後新建一個陣列Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
接下來就要一個個從老的陣列裡讀取元素，然後重新hash，重新塞一遍，非常耗效能；所以，如果一開始就能預估出有多少資料，在初始化的時候就指定數量public HashMap(int initialCapacity)；
通過(e.hash & oldCap) == 0來判斷元素應該屬於高區還是低區
比如oldCap==100==4, newCap=100<<1=1000==8原來塞的時候是e.hash是1001，1001 & 1==1塞在第一個槽位，那麼1001&100==0就塞回原位，與1001&(1000-1)=1塞在1是一樣的；而另外一個e.hash=10101&100=101,就要塞(1+100)到高位去了，和10101&(1000-1)=101算出來是一樣的；看，數學多奇妙；這裡其實就是到高位後111中把第一個1取出來，分一下高低位就可以，但是大大優化了效率；

這裡有個可能發生的死迴圈（resize後進行get操作），如果兩個執行緒同時擴容，又同時建立了兩個新陣列，那麼在某個槽位，移動同一批Node的時候，比如有個三四個Node分別是a、b、c，上面這個迴圈是通過e=e.next+loTail.next = e來迴圈讀的，本來執行緒1的loTail已經移動到b了，後面繼續掛個c就完美收官了，這個時候執行緒2把e突然替換成了a，然後就loTail.next=a,這樣a.next=b,b.next=a；下次你get的時候，就在b和a之間繞不出來了；game over；