1.HashMap是執行緒安全的麼？併發環境下有什麼替代方案？

1.1 HashMap不是執行緒安全。
1.2 併發環境下替代方案有HashTable（所有方法加synchronized）， ConcurrentHashMap（用分段鎖實現執行緒安全）。

2.ConcurrentHashMap是如何實現執行緒安全的？

2.1 JDK1.7中是用Segment（extends ReentrantLock）來實現。

    /**
     * The segments, each of which is a specialized hash table.
     */
    final
 
 Segment<K,V>[] segments;//ConcurrentHashMap 有一個Segment陣列，也就是說他裡面有很多鎖

來看看Segment是何方聖神

    //原來就是一把鎖
    static final class Segment<K,V> extends ReentrantLock implements Serializable {


        /**
         * The per-segment table. Elements are accessed via
         * entryAt/setEntryAt providing volatile semantics.
         */
 

        transient volatile HashEntry<K,V>[] table;//這裡的結構就和HashMap 差不多了

來看看怎麼put的

    public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if
 
 ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);//哈哈，原來是根據hash獲取到元素要放在哪個Segment中，然後呼叫了Segment的put方法
    }

那看看Segment的put是什麼鬼

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            HashEntry<K,V> node = tryLock() ? null ://重點 先tryLock獲取鎖
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();//重點 釋放鎖
            }
            return oldValue;
        }

好了，總結一下

JDK1.7中ConcurrentHashMap是用一個二維陣列連結串列來實現的。其實就是一個Segment的陣列，每個Segment又是一個數組連結串列，而且是一個鎖，每次對同一個Segment中元素進行寫操作的時候，會鎖住整個Segment。
那和HashTable比較一下，有什麼好處呢？
好處就是，ConcurrentHashMap寫操作只會鎖一段（鎖住Segment中所有元素），對不同Segment元素的操作不會互相阻塞，而HashTable用的是synchronized，會鎖住整個物件，相當於一個HashTable上的操作都是並行的，連get方法都會阻塞其他操作。
換個說法吧，一個HashTable只有一把鎖，最多隻有一個執行緒獲取到鎖。
ConcurrentHashMap有很多把鎖（比如16），那麼此時最多支援16個併發（一個併發一把鎖，人人有份，不用搶），當然了，最理想的場景是16個併發操作的Segment都不一樣。

2.2 JDK1.8如何實現執行緒安全的

改進一：取消segments欄位，直接採用transient volatile HashEntry<K,V>[] table儲存資料，採用table陣列元素作為鎖，從而實現了對每一行資料進行加鎖，進一步減少併發衝突的概率。

改進二：將原先table陣列＋單向連結串列的資料結構，變更為table陣列＋單向連結串列＋紅黑樹的結構。對於hash表來說，最核心的能力在於將key hash之後能均勻的分佈在陣列中。如果hash之後雜湊的很均勻，那麼table陣列中的每個佇列長度主要為0或者1。但實際情況並非總是如此理想，雖然ConcurrentHashMap類預設的載入因子為0.75，但是在資料量過大或者運氣不佳的情況下，還是會存在一些佇列長度過長的情況，如果還是採用單向列表方式，那麼查詢某個節點的時間複雜度為O(n)；因此，對於個數超過8(預設值)的列表，jdk1.8中採用了紅黑樹的結構，那麼查詢的時間複雜度可以降低到O(logN)，可以改進效能。

為了說明以上2個改動，看一下put操作是如何實現的。

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 如果table為空，初始化；否則，根據hash值計算得到陣列索引i，如果tab[i]為空，直接新建節點Node即可。注：tab[i]實質為連結串列或者紅黑樹的首節點。
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 如果tab[i]不為空並且hash值為MOVED，說明該連結串列正在進行transfer操作，返回擴容完成後的table。
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 針對首個節點進行加鎖操作，而不是segment，進一步減少執行緒衝突
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 如果在連結串列中找到值為key的節點e，直接設定e.val = value即可。
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            // 如果沒有找到值為key的節點，直接新建Node並加入連結串列即可。
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 如果首節點為TreeBin型別，說明為紅黑樹結構，執行putTreeVal操作。
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                // 如果節點數>＝8，那麼轉換連結串列結構為紅黑樹結構。
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 計數增加1，有可能觸發transfer操作(擴容)。
    addCount(1L, binCount);
    return null;
}



時間過得真快，不寫這個部落格，還不知道1.8改動這麼大，逝者如斯夫，不捨晝夜，吾將上下而求索。