在并發(fā)的情況下，通常使用ConcurrentHashMap來(lái)保證程序的效率

簡(jiǎn)介

ConcurrentHashMap原理是當(dāng)一個(gè)線程占用鎖訪問(wèn)其中一個(gè)段數(shù)據(jù)的時(shí)候，
其他段的數(shù)據(jù)也能被其他線程訪問(wèn)，
能夠?qū)崿F(xiàn)真正的并發(fā)訪問(wèn)。

據(jù)說(shuō)曾經(jīng)的
ConcurrentHashMap使用分段鎖技術(shù)，segment鎖，保護(hù)了多個(gè)hash桶
將數(shù)據(jù)分成一段一段的存儲(chǔ)，
然后給每一段數(shù)據(jù)配一把鎖。（老代碼懶得去找了~~~~）

在JDK8里面變成了只對(duì)訪問(wèn)的hash桶加鎖，一個(gè)鎖只保護(hù)一個(gè)hash桶，細(xì)粒度更小，寫操作的并發(fā)的到提升。

PUT方法

concurrentHashMap是通過(guò)casTabAt來(lái)保證值得可見性。

在不加鎖的情況下，線程A使用casTabAt方法對(duì)map進(jìn)行操作，線程B能夠直接使用tabAt訪問(wèn)到map里面的值。

通過(guò)for循環(huán)+CAS操作，實(shí)現(xiàn)并發(fā)安全的方式就是無(wú)鎖算法（lock free)的經(jīng)典實(shí)現(xiàn)。

如果存在hash沖突，會(huì)對(duì)使用native方法tabAt讀取出來(lái)的f加鎖，對(duì)f進(jìn)行轉(zhuǎn)換成鏈表或者樹的處理

/**
 * 這個(gè)變量初次初始化時(shí)候會(huì)被創(chuàng)建
 */
transient volatile Node<K,V>[] table;
/** 用于控制整個(gè)變量的操作，初始為0 */
private transient volatile int sizeCtl;
public V put(K key, V value) {
    return putVal(key, value, false);
}

/** 實(shí)現(xiàn)PUT方法 */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    // Key不允許為空
    if (key == null || value == null) throw new NullPointerException();
    // 計(jì)算key的hash值防碰撞
    int hash = spread(key.hashCode());
    int binCount = 0;
    // 這邊寫一個(gè)死循環(huán)
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 如果表沒(méi)有進(jìn)行初始化則進(jìn)行一個(gè)初始化
        if (tab == null || (n = tab.length) == 0)
            // 初始化
            tab = initTable();
            // 初始化之后進(jìn)行下一輪循環(huán)
 
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 如果Map的最后i個(gè)元素為空,創(chuàng)建一個(gè)Node放到tab的第i個(gè)位置
            // 使用casTabAt進(jìn)行塞值，如果塞失敗會(huì)重新進(jìn)行循環(huán)來(lái)處理
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            // 有一模一樣的Hash值存在
            V oldVal = null;
            // 對(duì)存在沖突的那個(gè)對(duì)象加鎖
            synchronized (f) {
                // 如果那個(gè)對(duì)象還沒(méi)有轉(zhuǎn)換成樹
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 比較他們的當(dāng)前鎖住的對(duì)象f和傳進(jìn)來(lái)的hash值相同，Key相同或者對(duì)象地址相同
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                 // 相同值進(jìn)行替換
                                oldVal = e.val;
                            if (!onlyIfAbsent)
                                e.val = value;
                                break;
                            }
                            // 否則以鏈表的形式跟在后面
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 成樹操作
                    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) {
                // 如果超過(guò)一個(gè)樹的最大容量直接轉(zhuǎn)換成樹
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}
/** 初始化 */
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // sizeCtl小于0，說(shuō)明已經(jīng)有線程在對(duì)它進(jìn)行處理，當(dāng)前線程進(jìn)行創(chuàng)建的時(shí)候則需要先等等
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // 使用底層代碼保證只有一個(gè)值來(lái)改變sc的值   SIZECTL是當(dāng)前類的內(nèi)存地址，將狀態(tài)修改成-1 
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // DEFAULT_CAPACITY初始化為16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 創(chuàng)建一個(gè)長(zhǎng)度為n的數(shù)組
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

GET方法

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    // 計(jì)算Hash
    int h = spread(key.hashCode());
    // 如果表不為空，且hash值存在
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // key相同直接返回
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 如果上面連段邏輯都沒(méi)有執(zhí)行，使用鏈表的方式一段一段往下找    
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}