說(shuō)明:

最近在搞并發(fā)相關(guān)知識(shí),學(xué)習(xí)到ConcurrentHashMap ,所有找了相關(guān)資料,目前找到一篇不錯(cuò)的文章,現(xiàn)用markdown 語(yǔ)法寫在此,供以后使用,本篇文章并發(fā)自己所做,原文鏈接 https://crossoverjie.top/2018/07/23/java-senior/ConcurrentHashMap/

文章前言

Map 這樣的 Key Value 在軟件開發(fā)中是非常經(jīng)典的結(jié)構(gòu)伶棒，常用于在內(nèi)存中存放數(shù)據(jù)暂殖。
本篇主要想討論 ConcurrentHashMap 這樣一個(gè)并發(fā)容器祥诽，在正式開始之前我覺(jué)得有必要談?wù)?HashMap，沒(méi)有它就不會(huì)有后面的 ConcurrentHashMap。

一 、HashMap

眾所周知 HashMap 底層是基于 數(shù)組 + 鏈表 組成的，不過(guò)在 jdk1.7 和 1.8 中具體實(shí)現(xiàn)稍有不同。

Base 1.7

1.7 中的數(shù)據(jù)結(jié)構(gòu)圖：

hashMap 表結(jié)構(gòu)

先來(lái)看看 1.7 中的實(shí)現(xiàn)第晰。

image.png

初始化桶大小茁瘦，因?yàn)榈讓邮菙?shù)組品抽，所以這是數(shù)組默認(rèn)的大小。
桶最大值甜熔。
默認(rèn)的負(fù)載因子（0.75）
table 真正存放數(shù)據(jù)的數(shù)組圆恤。
Map 存放數(shù)量的大小。
桶大小腔稀，可在初始化時(shí)顯式指定盆昙。
負(fù)載因子，可在初始化時(shí)顯式指定焊虏。
重點(diǎn)解釋下負(fù)載因子：

由于給定的 HashMap 的容量大小是固定的淡喜，比如默認(rèn)初始化：

public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    threshold = initialCapacity;
    init();
}

給定的默認(rèn)容量為 16，負(fù)載因子為 0.75诵闭。Map 在使用過(guò)程中不斷的往里面存放數(shù)據(jù)炼团，當(dāng)數(shù)量達(dá)到了 16 * 0.75 = 12 就需要將當(dāng)前 16 的容量進(jìn)行擴(kuò)容，而擴(kuò)容這個(gè)過(guò)程涉及到 rehash涂圆、復(fù)制數(shù)據(jù)等操作们镜，所以非常消耗性能。

因此通常建議能提前預(yù)估 HashMap 的大小最好润歉，盡量的減少擴(kuò)容帶來(lái)的性能損耗。

根據(jù)代碼可以看到其實(shí)真正存放數(shù)據(jù)的是 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
這個(gè)數(shù)組颈抚，那么它又是如何定義的呢踩衩？

image.png

Entry 是 HashMap 中的一個(gè)內(nèi)部類，從他的成員變量很容易看出：

key 就是寫入時(shí)的鍵贩汉。
value 自然就是值驱富。
開始的時(shí)候就提到 HashMap 是由數(shù)組和鏈表組成，所以這個(gè) next 就是用于實(shí)現(xiàn)鏈表結(jié)構(gòu)匹舞。
hash 存放的是當(dāng)前 key 的 hashcode褐鸥。
知曉了基本結(jié)構(gòu)，那來(lái)看看其中重要的寫入赐稽、獲取函數(shù)：

put 方法

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

判斷當(dāng)前數(shù)組是否需要初始化叫榕。

• 如果 key 為空，則 put 一個(gè)空值進(jìn)去姊舵。

• 根據(jù) key 計(jì)算出 hashcode晰绎。
• 根據(jù)計(jì)算出的 hashcode 定位出所在桶。
• 如果桶是一個(gè)鏈表則需要遍歷判斷里面的 hashcode括丁、key 是否和傳入 key 相等荞下，如果相等則進(jìn)行覆蓋，并- - 返回原來(lái)的值。
• 如果桶是空的尖昏，說(shuō)明當(dāng)前位置沒(méi)有數(shù)據(jù)存入仰税；新增一個(gè) Entry 對(duì)象寫入當(dāng)前位置。

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

當(dāng)調(diào)用 addEntry 寫入 Entry 時(shí)需要判斷是否需要擴(kuò)容抽诉。
如果需要就進(jìn)行兩倍擴(kuò)充陨簇，并將當(dāng)前的 key 重新 hash 并定位。
而在 createEntry 中會(huì)將當(dāng)前位置的桶傳入到新建的桶中掸鹅，如果當(dāng)前桶有值就會(huì)在位置形成鏈表塞帐。

get 方法

再來(lái)看看 get 函數(shù)：

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);
    return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }
    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

• 首先也是根據(jù) key 計(jì)算出 hashcode，然后定位到具體的桶中巍沙。
• 判斷該位置是否為鏈表葵姥。
• 不是鏈表就根據(jù) key、key 的 hashcode 是否相等來(lái)返回值句携。
• 為鏈表則需要遍歷直到 key 及 hashcode 相等時(shí)候就返回值榔幸。
• 啥都沒(méi)取到就直接返回 null 。

Base 1.8
不知道 1.7 的實(shí)現(xiàn)大家看出需要優(yōu)化的點(diǎn)沒(méi)有矮嫉？
其實(shí)一個(gè)很明顯的地方就是：

當(dāng) Hash 沖突嚴(yán)重時(shí)削咆，在桶上形成的鏈表會(huì)變的越來(lái)越長(zhǎng)，這樣在查詢時(shí)的效率就會(huì)越來(lái)越低蠢笋；時(shí)間復(fù)雜度為 O(N)拨齐。
因此 1.8 中重點(diǎn)優(yōu)化了這個(gè)查詢效率。
1.8 HashMap 結(jié)構(gòu)圖：

image.png

先來(lái)看看幾個(gè)核心的成員變量：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
 * The maximum capacity, used if a higher value is implicitly specified
 * by either of the constructors with arguments.
 * MUST be a power of two <= 1<<30.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
transient Node<K,V>[] table;
/**
 * Holds cached entrySet(). Note that AbstractMap fields are used
 * for keySet() and values().
 */
transient Set<Map.Entry<K,V>> entrySet;
/**
 * The number of key-value mappings contained in this map.
 */
transient int size;

和 1.7 大體上都差不多昨寞，還是有幾個(gè)重要的區(qū)別：

• TREEIFY_THRESHOLD 用于判斷是否需要將鏈表轉(zhuǎn)換為紅黑樹的閾值瞻惋。
• HashEntry 修改為 Node。
  Node 的核心組成其實(shí)也是和 1.7 中的 HashEntry 一樣援岩，存放的都是 key value hashcode next 等數(shù)據(jù)歼狼。
  再來(lái)看看核心方法。

put 方法

image.png

看似要比 1.7 的復(fù)雜享怀，我們一步步拆解：

1. 判斷當(dāng)前桶是否為空羽峰，空的就需要初始化（resize 中會(huì)判斷是否進(jìn)行初始化）。
2. 根據(jù)當(dāng)前 key 的 hashcode 定位到具體的桶中并判斷是否為空添瓷，為空表明沒(méi)有 Hash 沖突就直接在當(dāng)前位置創(chuàng)建一個(gè)新桶即可梅屉。
3. 如果當(dāng)前桶有值（ Hash 沖突），那么就要比較當(dāng)前桶中的 key仰坦、key 的 hashcode 與寫入的 key 是否相等履植，相等就賦值給 e,在第 8 步的時(shí)候會(huì)統(tǒng)一進(jìn)行賦值及返回。
4. 如果當(dāng)前桶為紅黑樹悄晃，那就要按照紅黑樹的方式寫入數(shù)據(jù)玫霎。
5. 如果是個(gè)鏈表凿滤，就需要將當(dāng)前的 key、value 封裝成一個(gè)新節(jié)點(diǎn)寫入到當(dāng)前桶的后面（形成鏈表）庶近。
6. 接著判斷當(dāng)前鏈表的大小是否大于預(yù)設(shè)的閾值翁脆，大于時(shí)就要轉(zhuǎn)換為紅黑樹。
7. 如果在遍歷過(guò)程中找到 key 相同時(shí)直接退出遍歷鼻种。
8. 如果 e != null 就相當(dāng)于存在相同的 key,那就需要將值覆蓋反番。
9. 最后判斷是否需要進(jìn)行擴(kuò)容。

get 方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

get 方法看起來(lái)就要簡(jiǎn)單許多了叉钥。

• 首先將 key hash 之后取得所定位的桶罢缸。
• 如果桶為空則直接返回 null 。
• 否則判斷桶的第一個(gè)位置(有可能是鏈表投队、紅黑樹)的 key 是否為查詢的 key枫疆，是就直接返回 value。
• 如果第一個(gè)不匹配敷鸦，則判斷它的下一個(gè)是紅黑樹還是鏈表息楔。
• 紅黑樹就按照樹的查找方式返回值。
• 不然就按照鏈表的方式遍歷匹配返回值扒披。

從這兩個(gè)核心方法（get/put）可以看出 1.8 中對(duì)大鏈表做了優(yōu)化值依，修改為紅黑樹之后查詢效率直接提高到了 O(logn)。

但是 HashMap 原有的問(wèn)題也都存在碟案，比如在并發(fā)場(chǎng)景下使用時(shí)容易出現(xiàn)死循環(huán)愿险。

final HashMap<String, String> map = new HashMap<String, String>();
for (int i = 0; i < 1000; i++) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            map.put(UUID.randomUUID().toString(), "");
        }
    }).start();
}

但是為什么呢？簡(jiǎn)單分析下价说。
看過(guò)上文的還記得在 HashMap 擴(kuò)容的時(shí)候會(huì)調(diào)用 resize() 方法拯啦，就是這里的并發(fā)操作容易在一個(gè)桶上形成環(huán)形鏈表；這樣當(dāng)獲取一個(gè)不存在的 key 時(shí)熔任，計(jì)算出的 index 正好是環(huán)形鏈表的下標(biāo)就會(huì)出現(xiàn)死循環(huán)。
如下圖：

image.png

image.png

遍歷方式

還有一個(gè)值得注意的是 HashMap 的遍歷方式唁情，通常有以下幾種：

Iterator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
        while (entryIterator.hasNext()) {
            Map.Entry<String, Integer> next = entryIterator.next();
            System.out.println("key=" + next.getKey() + " value=" + next.getValue());
        }
        
Iterator<String> iterator = map.keySet().iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            System.out.println("key=" + key + " value=" + map.get(key));
        }

強(qiáng)烈建議 使用第一種 EntrySet 進(jìn)行遍歷疑苔。
第一種可以把 key value 同時(shí)取出，第二種還得需要通過(guò) key 取一次 value甸鸟，效率較低惦费。

簡(jiǎn)單總結(jié)下 HashMap：無(wú)論是 1.7 還是 1.8 其實(shí)都能看出 JDK 沒(méi)有對(duì)它做任何的同步操作，所以并發(fā)會(huì)出問(wèn)題抢韭，甚至 1.7 中出現(xiàn)死循環(huán)導(dǎo)致系統(tǒng)不可用（1.8 已經(jīng)修復(fù)死循環(huán)問(wèn)題）薪贫。
因此 JDK 推出了專項(xiàng)專用的 ConcurrentHashMap ，該類位于 java.util.concurrent 包下刻恭，專門用于解決并發(fā)問(wèn)題瞧省。
堅(jiān)持看到這里的朋友算是已經(jīng)把 ConcurrentHashMap 的基礎(chǔ)已經(jīng)打牢了扯夭，下面正式開始分析。

ConcurrentHashMap

ConcurrentHashMap 同樣也分為 1.7 鞍匾、1.8 版交洗，兩者在實(shí)現(xiàn)上略有不同。

Base 1.7

先來(lái)看看 1.7 的實(shí)現(xiàn)橡淑，下面是他的結(jié)構(gòu)圖：

1.7結(jié)構(gòu)圖

如圖所示构拳，是由 Segment 數(shù)組、HashEntry 組成梁棠，和 HashMap 一樣置森，仍然是數(shù)組加鏈表。
它的核心成員變量：

/**
 * Segment 數(shù)組符糊，存放數(shù)據(jù)時(shí)首先需要定位到具體的 Segment 中凫海。
 */
final Segment<K,V>[] segments;
transient Set<K> keySet;
transient Set<Map.Entry<K,V>> entrySet;

Segment 是 ConcurrentHashMap 的一個(gè)內(nèi)部類，主要的組成如下：

   static final class Segment<K,V> extends ReentrantLock implements Serializable {
       private static final long serialVersionUID = 2249069246763182397L;
       
       // 和 HashMap 中的 HashEntry 作用一樣濒蒋，真正存放數(shù)據(jù)的桶
       transient volatile HashEntry<K,V>[] table;
       transient int count;
       transient int modCount;
       transient int threshold;
       final float loadFactor;
       
}

和 HashMap 非常類似盐碱，唯一的區(qū)別就是其中的核心數(shù)據(jù)如 value ，以及鏈表都是 volatile 修飾的沪伙，保證了獲取時(shí)的可見(jiàn)性瓮顽。

原理上來(lái)說(shuō)：ConcurrentHashMap 采用了分段鎖技術(shù)，其中 Segment 繼承于 ReentrantLock围橡。不會(huì)像 HashTable 那樣不管是 put 還是 get 操作都需要做同步處理暖混，理論上 ConcurrentHashMap 支持 CurrencyLevel (Segment 數(shù)組數(shù)量)的線程并發(fā)。每當(dāng)一個(gè)線程占用鎖訪問(wèn)一個(gè) Segment 時(shí)翁授，不會(huì)影響到其他的 Segment拣播。

下面也來(lái)看看核心的 put get 方法。

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);
}

首先是通過(guò) key 定位到 Segment收擦，之后在對(duì)應(yīng)的 Segment 中進(jìn)行具體的 put贮配。

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    HashEntry<K,V> node = tryLock() ? null :
        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;
}

雖然 HashEntry 中的 value 是用 volatile 關(guān)鍵詞修飾的，但是并不能保證并發(fā)的原子性塞赂，所以 put 操作時(shí)仍然需要加鎖處理泪勒。

首先第一步的時(shí)候會(huì)嘗試獲取鎖，如果獲取失敗肯定就有其他線程存在競(jìng)爭(zhēng)宴猾，則利用 scanAndLockForPut() 自旋獲取鎖圆存。

image.png

1. 嘗試自旋獲取鎖。

2. 如果重試的次數(shù)達(dá)到了 MAX_SCAN_RETRIES 則改為阻塞鎖獲取仇哆，保證能獲取成功沦辙。

   
   
   image.png
   
   

   再結(jié)合圖看看 put 的流程。

3. 將當(dāng)前 Segment 中的 table 通過(guò) key 的 hashcode 定位到 HashEntry讹剔。
4. 遍歷該 HashEntry油讯，如果不為空則判斷傳入的 key 和當(dāng)前遍歷的 key 是否相等详民，相等則覆蓋舊的 value。
5. 不為空則需要新建一個(gè) HashEntry 并加入到 Segment 中撞羽，同時(shí)會(huì)先判斷是否需要擴(kuò)容阐斜。
6. 最后會(huì)解除在 1 中所獲取當(dāng)前 Segment 的鎖。

get 方法

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key);
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

get 邏輯比較簡(jiǎn)單：

只需要將 Key 通過(guò) Hash 之后定位到具體的 Segment 诀紊，再通過(guò)一次 Hash 定位到具體的元素上谒出。

由于 HashEntry 中的 value 屬性是用 volatile 關(guān)鍵詞修飾的，保證了內(nèi)存可見(jiàn)性邻奠，所以每次獲取時(shí)都是最新值笤喳。

ConcurrentHashMap 的 get 方法是非常高效的，因?yàn)檎麄€(gè)過(guò)程都不需要加鎖碌宴。

Base 1.8

1.7 已經(jīng)解決了并發(fā)問(wèn)題杀狡，并且能支持 N 個(gè) Segment 這么多次數(shù)的并發(fā)，但依然存在 HashMap 在 1.7 版本中的問(wèn)題贰镣。

那就是查詢遍歷鏈表效率太低呜象。

因此 1.8 做了一些數(shù)據(jù)結(jié)構(gòu)上的調(diào)整。

首先來(lái)看下底層的組成結(jié)構(gòu)：

image.png

看起來(lái)是不是和 1.8 HashMap 結(jié)構(gòu)類似碑隆？

其中拋棄了原有的 Segment 分段鎖恭陡，而采用了 CAS + synchronized 來(lái)保證并發(fā)安全性。

image.png

put 方法

重點(diǎn)來(lái)看看 put 函數(shù)：

image.png

1. 根據(jù) key 計(jì)算出 hashcode 拴疤。
2. 判斷是否需要進(jìn)行初始化。
3. f 即為當(dāng)前 key 定位出的 Node独泞，如果為空表示當(dāng)前位置可以寫入數(shù)據(jù)呐矾，利用 CAS 嘗試寫入，失敗則自旋4. 保證成功懦砂。
4. 如果當(dāng)前位置的 hashcode == MOVED == -1,則需要進(jìn)行擴(kuò)容凫佛。
5. 如果都不滿足，則利用 synchronized 鎖寫入數(shù)據(jù)孕惜。
6. 如果數(shù)量大于 TREEIFY_THRESHOLD 則要轉(zhuǎn)換為紅黑樹。

get 方法

image.png

• 根據(jù)計(jì)算出來(lái)的 hashcode 尋址晨炕，如果就在桶上那么直接返回值衫画。
• 如果是紅黑樹那就按照樹的方式獲取值。
• 就不滿足那就按照鏈表的方式遍歷獲取值瓮栗。

1.8 在 1.7 的數(shù)據(jù)結(jié)構(gòu)上做了大的改動(dòng)削罩，采用紅黑樹之后可以保證查詢效率（O(logn)）瞄勾，甚至取消了 ReentrantLock 改為了 synchronized，這樣可以看出在新版的 JDK 中對(duì) synchronized 優(yōu)化是很到位的弥激。

總結(jié)

看完了整個(gè) HashMap 和 ConcurrentHashMap 在 1.7 和 1.8 中不同的實(shí)現(xiàn)方式相信大家對(duì)他們的理解應(yīng)該會(huì)更加到位进陡。

其實(shí)這塊也是面試的重點(diǎn)內(nèi)容，通常的套路是：

1. 談?wù)勀憷斫獾?HashMap微服，講講其中的 get put 過(guò)程趾疚。
2. 1.8 做了什么優(yōu)化？
3. 是線程安全的嘛以蕴？
4. 不安全會(huì)導(dǎo)致哪些問(wèn)題糙麦？
5. 如何解決？有沒(méi)有線程安全的并發(fā)容器丛肮？
6. ConcurrentHashMap 是如何實(shí)現(xiàn)的赡磅？ 1.7、1.8 實(shí)現(xiàn)有何不同宝与？為什么這么做焚廊？

這一串問(wèn)題相信大家仔細(xì)看完都能懟回面試官。

除了面試會(huì)問(wèn)到之外平時(shí)的應(yīng)用其實(shí)也蠻多习劫，像之前談到的 Guava 中 Cache 的實(shí)現(xiàn)就是利用 ConcurrentHashMap 的思想咆瘟。

同時(shí)也能學(xué)習(xí) JDK 作者大牛們的優(yōu)化思路以及并發(fā)解決方案。

其實(shí)寫這篇的前提是源于 GitHub 上的一個(gè) Issues榜聂，也希望大家能參與進(jìn)來(lái)搞疗，共同維護(hù)好這個(gè)項(xiàng)目。