ConcurrentHashMap，它在技術(shù)面試中出現(xiàn)的頻率相當(dāng)之高，所以我們必須對它深入理解和掌握。

談到 ConcurrentHashMap，就一定會(huì)想到 HashMap。HashMap 在我們的代碼中使用頻率更高，不需要考慮線程安全的地方，我們一般都會(huì)使用 HashMap。HashMap 的實(shí)現(xiàn)非常經(jīng)典，如果你讀過 HashMap 的源代碼，那么對 ConcurrentHashMap 源代碼的理解會(huì)相對輕松，因?yàn)閮烧卟捎玫臄?shù)據(jù)結(jié)構(gòu)是類似的

這篇文章主要講解ConcurrentHashMap的核心原理，并注釋詳細(xì)源碼，文章篇幅較長，可收藏再看

基本結(jié)構(gòu)

ConcurrentHashMap 是一個(gè)存儲(chǔ) key/value 對的容器，并且是線程安全的。我們先看 ConcurrentHashMap 的存儲(chǔ)結(jié)構(gòu)，如下圖：

雖然 ConcurrentHashMap 的底層數(shù)據(jù)結(jié)構(gòu)，和方法的實(shí)現(xiàn)細(xì)節(jié)和 HashMap 大體一致，但兩者在類結(jié)構(gòu)上卻沒有任何關(guān)聯(lián)，我們看下 ConcurrentHashMap 的類圖：

看 ConcurrentHashMap 源碼，我們會(huì)發(fā)現(xiàn)很多方法和代碼和 HashMap 很相似，有的同學(xué)可能會(huì)問，為什么不繼承 HashMap 呢？

繼承的確是個(gè)好辦法，但ConcurrentHashMap 都是在方法中間進(jìn)行一些加鎖操作，也就是說加鎖把方法切割了，繼承就很難解決這個(gè)問題。

ConcurrentHashMap和HashMap兩者的相同之處：

數(shù)組、鏈表結(jié)構(gòu)幾乎相同，所以底層對數(shù)據(jù)結(jié)構(gòu)的操作思路是相同的（只是思路相同，底層實(shí)現(xiàn)不同）；

都實(shí)現(xiàn)了 Map 接口，繼承了 AbstractMap 抽象類，所以大多數(shù)的方法也都是相同的，HashMap 有的方法，ConcurrentHashMap 幾乎都有，所以當(dāng)我們需要從 HashMap 切換到 ConcurrentHashMap 時(shí)，無需關(guān)心兩者之間的兼容問題。

不同之處：

紅黑樹結(jié)構(gòu)略有不同，HashMap 的紅黑樹中的節(jié)點(diǎn)叫做 TreeNode，TreeNode 不僅僅有屬性，還維護(hù)著紅黑樹的結(jié)構(gòu)，比如說查找，新增等等；ConcurrentHashMap 中紅黑樹被拆分成兩塊，TreeNode 僅僅維護(hù)的屬性和查找功能，新增了 TreeBin，來維護(hù)紅黑樹結(jié)構(gòu)，并負(fù)責(zé)根節(jié)點(diǎn)的加鎖和解鎖；

新增 ForwardingNode （轉(zhuǎn)移）節(jié)點(diǎn)，擴(kuò)容的時(shí)候會(huì)使用到，通過使用該節(jié)點(diǎn)，來保證擴(kuò)容時(shí)的線程安全。

這些概念名詞文章后面都會(huì)依次介紹

基本構(gòu)成

重要屬性

我們來看看 ConcurrentHashMap 的幾個(gè)重要屬性

//這個(gè)Node數(shù)組就是ConcurrentHashMap用來存儲(chǔ)數(shù)據(jù)的哈希表。
transient?volatile?Node[]?table
//這是默認(rèn)的初始化哈希表數(shù)組大小
private?static?final?int?DEFAULT_CAPACITY?=?16;
//轉(zhuǎn)化為紅黑樹的鏈表長度閾值
static?final?int?TREEIFY_THRESHOLD?=?8
//這個(gè)標(biāo)識(shí)位用于識(shí)別擴(kuò)容時(shí)正在轉(zhuǎn)移數(shù)據(jù)
static?final?int?MOVED?=?-1
//計(jì)算哈希值時(shí)用到的參數(shù)，用來去除符號位
static?final?int?HASH_BITS?=?0x7fffffff;
//數(shù)據(jù)轉(zhuǎn)移時(shí)，新的哈希表數(shù)組
private?transient?volatile?Node[]?nextTable;

重要組成元素

Node

“
鏈表中的元素為Node對象。他是鏈表上的一個(gè)節(jié)點(diǎn)，內(nèi)部存儲(chǔ)了key、value值，以及他的下一個(gè)節(jié)點(diǎn)的引用。這樣一系列的Node就串成一串，組成一個(gè)鏈表。
”

ForwardingNode

“
當(dāng)進(jìn)行擴(kuò)容時(shí)，要把鏈表遷移到新的哈希表，在做這個(gè)操作時(shí)，會(huì)在把數(shù)組中的頭節(jié)點(diǎn)替換為ForwardingNode對象。ForwardingNode中不保存key和value，只保存了擴(kuò)容后哈希表（nextTable）的引用。此時(shí)查找相應(yīng)node時(shí)，需要去nextTable中查找。
”

TreeBin

“
當(dāng)鏈表轉(zhuǎn)為紅黑樹后，數(shù)組中保存的引用為 TreeBin，TreeBin 內(nèi)部不保存 key/value，他保存了 TreeNode的list以及紅黑樹 root。
”

TreeNode

“
紅黑樹的節(jié)點(diǎn)。
”

下面依次講解各個(gè)核心方法，有詳細(xì)注釋

put方法

public?V?put(K?key,?V?value)?{
????return?putVal(key,?value,?false);
}

ConcurrentHashMap 在 put 方法上的整體思路和 HashMap 相同，但在線程安全方面寫了很多保障的代碼，我們先來看下大體思路：

1.如果數(shù)組為空，初始化，初始化完成之后，走 2；

2.計(jì)算當(dāng)前槽點(diǎn)有沒有值，沒有值的話，cas 創(chuàng)建，失敗繼續(xù)自旋（for 死循環(huán)），直到成功，槽點(diǎn)有值的話，走 3；

3.如果槽點(diǎn)是轉(zhuǎn)移節(jié)點(diǎn)(正在擴(kuò)容)，就會(huì)一直自旋等待擴(kuò)容完成之后再新增，不是轉(zhuǎn)移節(jié)點(diǎn)走 4；

4.槽點(diǎn)有值的，先鎖定當(dāng)前槽點(diǎn)，保證其余線程不能操作，如果是鏈表，新增值到鏈表的尾部，如果是紅黑樹，使用紅黑樹新增的方法新增；

5.新增完成之后 check 需不需要擴(kuò)容，需要的話去擴(kuò)容。

ConcurrentHashMap在put過程中，采用了哪些手段來保證線程安全呢？

數(shù)組初始化時(shí)的線程安全

數(shù)組初始化時(shí)，首先通過自旋來保證一定可以初始化成功，然后通過 CAS 設(shè)置 SIZECTL 變量的值，來保證同一時(shí)刻只能有一個(gè)線程對數(shù)組進(jìn)行初始化，CAS 成功之后，還會(huì)再次判斷當(dāng)前數(shù)組是否已經(jīng)初始化完成，如果已經(jīng)初始化完成，就不會(huì)再次初始化，通過自旋 + CAS + 雙重 check 等手段保證了數(shù)組初始化時(shí)的線程安全

那么接下來我們就來看看 initTable 方法。

注意里面有個(gè)關(guān)鍵的值 sizeCtl，這個(gè)值有多個(gè)含義。

1、-1 代表有線程正在創(chuàng)建 table；

2、-N 代表有 N-1 個(gè)線程正在復(fù)制 table；

3、在 table 被初始化前，代表根據(jù)構(gòu)造函數(shù)傳入的值計(jì)算出的應(yīng)被初始化的大??；

4、在 table 被初始化后，則被設(shè)置為 table 大小的 75%，代表 table 的容量（數(shù)組容量）。

新增槽點(diǎn)值時(shí)的線程安全

此時(shí)為了保證線程安全，做了四處優(yōu)化：

1.通過自旋死循環(huán)保證一定可以新增成功。

在新增之前，通過 for (Node[] tab = table;;)這樣的死循環(huán)來保證新增一定可以成功，一旦新增成功，就可以退出當(dāng)前死循環(huán)，新增失敗的話，會(huì)重復(fù)新增的步驟，直到新增成功為止。

2.當(dāng)前槽點(diǎn)為空時(shí)，通過 CAS 新增。

Java 這里的寫法非常嚴(yán)謹(jǐn)，沒有在判斷槽點(diǎn)為空的情況下直接賦值，因?yàn)樵谂袛嗖埸c(diǎn)為空和賦值的瞬間，很有可能槽點(diǎn)已經(jīng)被其他線程賦值了，所以我們采用 CAS 算法，能夠保證槽點(diǎn)為空的情況下賦值成功，如果恰好槽點(diǎn)已經(jīng)被其他線程賦值，當(dāng)前 CAS 操作失敗，會(huì)再次執(zhí)行 for 自旋，再走槽點(diǎn)有值的 put 流程，這里就是自旋 + CAS 的結(jié)合。

3.當(dāng)前槽點(diǎn)有值，鎖住當(dāng)前槽點(diǎn)。

put 時(shí)，如果當(dāng)前槽點(diǎn)有值，就是 key 的 hash 沖突的情況，此時(shí)槽點(diǎn)上可能是鏈表或紅黑樹，我們通過鎖住槽點(diǎn)，來保證同一時(shí)刻只會(huì)有一個(gè)線程能對槽點(diǎn)進(jìn)行修改

V?oldVal?=?null;
//鎖定當(dāng)前槽點(diǎn)，其余線程不能操作，保證了安全
synchronized?(f)?{

4.紅黑樹旋轉(zhuǎn)時(shí)，鎖住紅黑樹的根節(jié)點(diǎn)，保證同一時(shí)刻，當(dāng)前紅黑樹只能被一個(gè)線程旋轉(zhuǎn)

Hash算法

spread方法源碼分析

哈希算法的邏輯，決定 ConcurrentHashMap 保存和讀取速度。

static?final?int?spread(int?h)?{
????return?(h?^?(h?>>>?16))?&?HASH_BITS;
}

傳入的參數(shù)h為 key 對象的 hashCode，spreed 方法對 hashCode 進(jìn)行了加工。重新計(jì)算出 hash。

hash 值是用來映射該 key 值在哈希表中的位置。取出哈希表中該 hash 值對應(yīng)位置的代碼如下。

tabAt(tab,?i?=?(n?-?1)?&?hash);

我們先看這一行代碼的邏輯，第一個(gè)參數(shù)為哈希表，第二個(gè)參數(shù)是哈希表中的數(shù)組下標(biāo)。通過 (n - 1) & hash 計(jì)算下標(biāo)。n 為數(shù)組長度，我們以默認(rèn)大小 16 為例，那么 n-1 = 15，我們可以假設(shè) hash 值為 100

n的值15轉(zhuǎn)為二進(jìn)制：
0000?0000?0000?0000?0000?0000?0000?1111
hash的值100轉(zhuǎn)為二進(jìn)制：
0000?0000?0000?0000?0000?0000?0110?0100。
計(jì)算結(jié)果：
0000?0000?0000?0000?0000?0000?0000?0100
對應(yīng)的十進(jìn)制值為?4

15的二進(jìn)制高位都為0，低位都是1。那么經(jīng)過&計(jì)算后，hash值100的高位全部被清零，低位則保持不變，并且一定是小于（n-1）的。也就是說經(jīng)過如此計(jì)算，通過hash值得到的數(shù)組下標(biāo)絕對不會(huì)越界。

這里提出幾個(gè)問題：

1、數(shù)組大小可以為 17，或者 18 嗎？

2、如果為了保證不越界為什么不直接用 % 計(jì)算取余數(shù)？

3、為什么不直接用 key 的 hashCode，而是使用經(jīng) spreed 方法加工后的 hash 值？

數(shù)組大小必須為 2 的 n 次方

第一個(gè)問題的答案是數(shù)組大小必須為 2 的 n 次方，也就是 16、32、64….不能為其他值。因?yàn)槿绻皇?2 的 n 次方，那么經(jīng)過計(jì)算的數(shù)組下標(biāo)會(huì)增大碰撞的幾率

如果hash值的二進(jìn)制是 10000（十進(jìn)制16）、10010（十進(jìn)制18）、10001（十進(jìn)制17），和10100做&計(jì)算后，都是10000，也就是都被映射到數(shù)組16這個(gè)下標(biāo)上。這三個(gè)值會(huì)以鏈表的形式存儲(chǔ)在數(shù)組16下標(biāo)的位置。這顯然不是我們想要的結(jié)果。

但如果數(shù)組長度n為2的n次方，2進(jìn)制的數(shù)值為10，100，1000，10000……n-1后對應(yīng)二進(jìn)制為1，11，111，1111……這樣和hash值低位&后，會(huì)保留原來hash值的低位數(shù)值，那么只要hash值的低位不一樣，就不會(huì)發(fā)生碰撞。

同時(shí)(n - 1) & hash等價(jià)于 hash%n。那么為什么不直接用hash%n呢？

這是因?yàn)榘次坏牟僮餍蕰?huì)更高。

為什么不直接用 key 的 hashCode？

其實(shí)說到底還是為了減少碰撞的概率。我們先看看 spreed 方法中的代碼做了什么事情：

h?^?(h?>>>?16)

這個(gè)意思是把 h 的二進(jìn)制數(shù)值向右移動(dòng) 16 位。我們知道整形為 32 位，那么右移 16 位后，就是把高 16 位移到了低 16 位。而高 16 位清0了。

^為異或操作，二進(jìn)制按位比較，如果相同則為 0，不同則為 1。這行代碼的意思就是把高低16位做異或。如果兩個(gè)hashCode值的低16位相同，但是高位不同，經(jīng)過如此計(jì)算，低16位會(huì)變得不一樣了。

為什么要把低位變得不一樣呢？

這是由于哈希表數(shù)組長度n會(huì)是偏小的數(shù)值，那么進(jìn)行(n - 1) & hash運(yùn)算時(shí)，一直使用的是hash較低位的值。那么即使hash值不同，但如果低位相當(dāng)，也會(huì)發(fā)生碰撞。而進(jìn)行h ^ (h >>> 16)加工后的hash值，讓hashCode高位的值也參與了哈希運(yùn)算，因此減少了碰撞的概率。

(h?^?(h?>>>?16))?&?HASH_BITS

為何高位移到低位和原來低位做異或操作后，還需要和HASH_BITS這個(gè)常量做 & 計(jì)算呢？HASH_BITS 這個(gè)常量的值為 0x7fffffff，轉(zhuǎn)化為二進(jìn)制為 0111 1111 1111 1111 1111 1111 1111 1111。這個(gè)操作后會(huì)把最高位轉(zhuǎn)為 0，其實(shí)就是消除了符號位，得到的都是正數(shù)。這是因?yàn)樨?fù)的 hashCode 在ConcurrentHashMap 中有特殊的含義，因此我們需要得到一個(gè)正的 hashCode。

擴(kuò)容源碼分析

我們大致了解了ConcurrentHashMap 的存儲(chǔ)結(jié)構(gòu)，那么我們思考一個(gè)問題，當(dāng)數(shù)組中保存的鏈表越來越多，那么再存儲(chǔ)進(jìn)來的元素大概率會(huì)插入到現(xiàn)有的鏈表中，而不是使用數(shù)組中剩下的空位。這樣會(huì)造成數(shù)組中保存的鏈表越來越長，由此導(dǎo)致哈希表查找速度下降，從 O(1) 慢慢趨近于鏈表的時(shí)間復(fù)雜度 O(n/2)，這顯然違背了哈希表的初衷。

所以ConcurrentHashMap 會(huì)做一個(gè)操作，稱為擴(kuò)容。也就是把數(shù)組長度變大，增加更多的空位出來，最終目的就是預(yù)防鏈表過長，這樣查找的時(shí)間復(fù)雜度才會(huì)趨向于 O(1)。

擴(kuò)容的操作并不會(huì)在數(shù)組沒有空位時(shí)才進(jìn)行，因?yàn)樵谕拔豢鞚M時(shí)，新保存元素更大的概率會(huì)命中已經(jīng)使用的位置，那么可能最后幾個(gè)桶位很難被使用，而鏈表卻越來越長了。

另外 ConcurrentHashMap 還會(huì)有鏈表轉(zhuǎn)紅黑樹的操作，以提高查找的速度，紅黑樹時(shí)間復(fù)雜度為 O(logn)，而鏈表是 O(n/2)，因此只在 O(logn) 時(shí)才會(huì)進(jìn)行轉(zhuǎn)換，也就是以 8 作為分界點(diǎn)。

接下來我們分析 treeifyBin 方法代碼，這個(gè)代碼中會(huì)選擇是把此時(shí)保存數(shù)據(jù)所在的鏈表轉(zhuǎn)為紅黑樹，還是對整個(gè)哈希表擴(kuò)容

我們再重點(diǎn)看一下 tryPresize，此方法中實(shí)現(xiàn)了對數(shù)組的擴(kuò)容，傳入的參數(shù) size 是原來哈希表大小的一倍。我們假定原來哈希表大小為 16，那么傳入的 size 值為 32

ConcurrentHashMap 的擴(kuò)容時(shí)機(jī)和 HashMap 相同，都是在 put 方法的最后一步檢查是否需要擴(kuò)容，如果需要?jiǎng)t進(jìn)行擴(kuò)容，但兩者擴(kuò)容的過程完全不同，ConcurrentHashMap 擴(kuò)容的方法叫做 transfer，從 put 方法的 addCount 方法進(jìn)去，就能找到 transfer 方法，transfer 方法的主要思路是：

1.首先需要把老數(shù)組的值全部拷貝到擴(kuò)容之后的新數(shù)組上，先從數(shù)組的隊(duì)尾開始拷貝；

2.拷貝數(shù)組的槽點(diǎn)時(shí)，先把原數(shù)組槽點(diǎn)鎖住，保證原數(shù)組槽點(diǎn)不能操作，成功拷貝到新數(shù)組時(shí)，把原數(shù)組槽點(diǎn)賦值為轉(zhuǎn)移節(jié)點(diǎn)；

3.這時(shí)如果有新數(shù)據(jù)正好需要 put 到此槽點(diǎn)時(shí)，發(fā)現(xiàn)槽點(diǎn)為轉(zhuǎn)移節(jié)點(diǎn)，就會(huì)一直等待，所以在擴(kuò)容完成之前，該槽點(diǎn)對應(yīng)的數(shù)據(jù)是不會(huì)發(fā)生變化的；

4.從數(shù)組的尾部拷貝到頭部，每拷貝成功一次，就把原數(shù)組中的節(jié)點(diǎn)設(shè)置成轉(zhuǎn)移節(jié)點(diǎn)；

5.直到所有數(shù)組數(shù)據(jù)都拷貝到新數(shù)組時(shí)，直接把新數(shù)組整個(gè)賦值給數(shù)組容器，拷貝完成。

擴(kuò)容方法主要是通過在原數(shù)組上設(shè)置轉(zhuǎn)移節(jié)點(diǎn)，put 時(shí)碰到轉(zhuǎn)移節(jié)點(diǎn)時(shí)會(huì)等待擴(kuò)容成功之后才能 put 的策略，來保證了整個(gè)擴(kuò)容過程中肯定是線程安全的，因?yàn)閿?shù)組的槽點(diǎn)一旦被設(shè)置成轉(zhuǎn)移節(jié)點(diǎn)，在沒有擴(kuò)容完成之前，是無法進(jìn)行操作的

`get方法`

ConcurrentHashMap 讀的話，就比較簡單，先獲取數(shù)組的下標(biāo)，然后通過判斷數(shù)組下標(biāo)的 key 是否和我們的 key 相等，相等的話直接返回，如果下標(biāo)的槽點(diǎn)是鏈表或紅黑樹的話，分別調(diào)用相應(yīng)的查找數(shù)據(jù)的方法，整體思路和 HashMap 很像

`構(gòu)造函數(shù)源碼`

public?ConcurrentHashMap(int?initialCapacity)?{
????if?(initialCapacity?0)
????????throw?new?IllegalArgumentException();
??//如果傳入的初始化容量值超過最大容量的一半，那么sizeCtl會(huì)被設(shè)置為最大容量。
??//否則通過tableSizeFor方法就算出一個(gè)2的n次方數(shù)值作為size
????int?cap?=?((initialCapacity?>=?(MAXIMUM_CAPACITY?>>>?1))??
???????????????MAXIMUM_CAPACITY?:
???????????????tableSizeFor(initialCapacity?+?(initialCapacity?>>>?1)?+?1));
????this.sizeCtl?=?cap;
}

這是一個(gè)有參數(shù)的構(gòu)造方法。如果你對未來存儲(chǔ)的數(shù)據(jù)量有預(yù)估，我們可以指定哈希表的大小，避免頻繁的擴(kuò)容操作。tableSizeFor 這個(gè)方法確保了哈希表的大小永遠(yuǎn)都是 2 的 n 次方。

注意這里傳入的參數(shù)不是 initialCapacity，而是 initialCapacity 的 1.5 倍 + 1。這樣做是為了保證在默認(rèn) 75% 的負(fù)載因子下，能夠足夠容納 initialCapacity 數(shù)量的元素。

ConcurrentHashMap (int initialCapacity) 構(gòu)造函數(shù)總結(jié)下：

1、構(gòu)造函數(shù)中并不會(huì)初始化哈希表；

2、構(gòu)造函數(shù)中僅設(shè)置哈希表大小的變量 sizeCtl；

3、initialCapacity 并不是哈希表大小；

4、哈希表大小為 initialCapacity*1.5+1 后，向上取最小的 2 的 n 次方。如果超過最大容量一半，那么就是最大容量。

tableSizeFor 是如何實(shí)現(xiàn)向上取得最接近入?yún)?2 的 n 次方的。下面我們來看 tableSizeFor 源代碼：

private?static?final?int?tableSizeFor(int?c)?{
????int?n?=?c?-?1;
????n?|=?n?>>>?1;
????n?|=?n?>>>?2;
????n?|=?n?>>>?4;
????n?|=?n?>>>?8;
????n?|=?n?>>>?16;
????return?(n?0)???1?:?(n?>=?MAXIMUM_CAPACITY)???MAXIMUM_CAPACITY?:?n?+?1;
}

依舊是二進(jìn)制按位操作，這樣一頓操作后，得到的數(shù)值就是大于 c 的最小 2 的 n 次。我們推演下過程，假設(shè) c 是 9：

1、int?n?=?9?-?1
n=8
2、n?|=?n?>>>?1
n=1000
n?>>>?1=0100
兩個(gè)值按位或后
n=1100
3、n?|=?n?>>>?2
n=1100
n?>>>?2=0011
n=1111

到這里可以看出規(guī)律來了。如果 c 足夠大，使得 n 很大，那么運(yùn)算到 n |= n >>> 16 時(shí)，n 的 32 位都為 1。

總結(jié)一下這一段邏輯，其實(shí)就是把 n 有數(shù)值的 bit 位全部置為 1。這樣就得到了一個(gè)肯定大于等于 n 的值。我們再看最后一行代碼，最終返回的是 n+1，那么一個(gè)所有位都是 1 的二進(jìn)制數(shù)字，+1 后得到的就是一個(gè) 2 的 n 次方數(shù)值。

推薦閱讀：