目錄
內容提要:
java7/8中HashMap和ConcurrentHashMap實現原理、源碼解析、數據結構、put和set方式
閱讀前提:
本文分析的是源碼,所以至少讀者要熟悉它們的接口使用,同時,對於併發,讀者至少要知道 CAS、ReentrantLock、UNSAFE 操作這幾個基本的知識,文中不會對這些知識進行介紹。Java8 用到了紅黑樹,不過本文不會進行展開,感興趣的讀者請自行查找相關資料。
Java7 HashMap
HashMap 是最簡單的,一來我們非常熟悉,二來就是它不支持併發操作,所以源碼也非常簡單。
首先,我們用下面這張圖來介紹 HashMap 的結構。
這個僅僅是示意圖,因爲沒有考慮到數組要擴容的情況,具體的後面再說。
大方向上,HashMap 裏面是一個數組,然後數組中每個元素是一個單向鏈表。
上圖中,每個綠色的實體是嵌套類 Entry 的實例,Entry 包含四個屬性:key, value, hash 值和用於單向鏈表的 next。
capacity:當前數組容量,始終保持 2^n,可以擴容,擴容後數組大小爲當前的 2 倍。
loadFactor:負載因子,默認爲 0.75。
threshold:擴容的閾值,等於 capacity * loadFactor
put 過程分析
還是比較簡單的,跟着代碼走一遍吧。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
|
數組初始化
在第一個元素插入 HashMap 的時候做一次數組的初始化,就是先確定初始的數組大小,並計算數組擴容的閾值。
1 2 3 4 5 6 7 8 9 10 |
|
這裏有一個將數組大小保持爲 2 的 n 次方的做法,Java7 和 Java8 的 HashMap 和 ConcurrentHashMap 都有相應的要求,只不過實現的代碼稍微有些不同,後面再看到的時候就知道了。
計算具體數組位置
這個簡單,我們自己也能 YY 一個:使用 key 的 hash 值對數組長度進行取模就可以了。
1 2 3 4 |
|
這個方法很簡單,簡單說就是取 hash 值的低 n 位。如在數組長度爲 32 的時候,其實取的就是 key 的 hash 值的低 5 位,作爲它在數組中的下標位置。
添加節點到鏈表中
找到數組下標後,會先進行 key 判重,如果沒有重複,就準備將新值放入到鏈表的表頭。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
|
這個方法的主要邏輯就是先判斷是否需要擴容,需要的話先擴容,然後再將這個新的數據插入到擴容後的數組的相應位置處的鏈表的表頭。
數組擴容
前面我們看到,在插入新值的時候,如果當前的 size 已經達到了閾值,並且要插入的數組位置上已經有元素,那麼就會觸發擴容,擴容後,數組大小爲原來的 2 倍。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
|
擴容就是用一個新的大數組替換原來的小數組,並將原來數組中的值遷移到新的數組中。
由於是雙倍擴容,遷移過程中,會將原來 table[i] 中的鏈表的所有節點,分拆到新的數組的 newTable[i] 和 newTable[i + oldLength] 位置上。如原來數組長度是 16,那麼擴容後,原來 table[0] 處的鏈表中的所有元素會被分配到新數組中 newTable[0] 和 newTable[16] 這兩個位置。代碼比較簡單,這裏就不展開了。
get 過程分析
相對於 put 過程,get 過程是非常簡單的。
- 根據 key 計算 hash 值。
- 找到相應的數組下標:hash & (length – 1)。
- 遍歷該數組位置處的鏈表,直到找到相等(==或equals)的 key。
1 2 3 4 5 6 7 8 9 |
|
getEntry(key):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
|
Java7 ConcurrentHashMap
ConcurrentHashMap 和 HashMap 思路是差不多的,但是因爲它支持併發操作,所以要複雜一些。
整個 ConcurrentHashMap 由一個個 Segment 組成,Segment 代表”部分“或”一段“的意思,所以很多地方都會將其描述爲分段鎖。注意,行文中,我很多地方用了“槽”來代表一個 segment。
簡單理解就是,ConcurrentHashMap 是一個 Segment 數組,Segment 通過繼承 ReentrantLock 來進行加鎖,所以每次需要加鎖的操作鎖住的是一個 segment,這樣只要保證每個 Segment 是線程安全的,也就實現了全局的線程安全。
concurrencyLevel:並行級別、併發數、Segment 數,怎麼翻譯不重要,理解它。默認是 16,也就是說 ConcurrentHashMap 有 16 個 Segments,所以理論上,這個時候,最多可以同時支持 16 個線程併發寫,只要它們的操作分別分佈在不同的 Segment 上。這個值可以在初始化的時候設置爲其他值,但是一旦初始化以後,它是不可以擴容的。
再具體到每個 Segment 內部,其實每個 Segment 很像之前介紹的 HashMap,不過它要保證線程安全,所以處理起來要麻煩些。
初始化
initialCapacity:初始容量,這個值指的是整個 ConcurrentHashMap 的初始容量,實際操作的時候需要平均分給每個 Segment。
loadFactor:負載因子,之前我們說了,Segment 數組不可以擴容,所以這個負載因子是給每個 Segment 內部使用的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
|
初始化完成,我們得到了一個 Segment 數組。
我們就當是用 new ConcurrentHashMap() 無參構造函數進行初始化的,那麼初始化完成後:
- Segment 數組長度爲 16,不可以擴容
- Segment[i] 的默認大小爲 2,負載因子是 0.75,得出初始閾值爲 1.5,也就是以後插入第一個元素不會觸發擴容,插入第二個會進行第一次擴容
- 這裏初始化了 segment[0],其他位置還是 null,至於爲什麼要初始化 segment[0],後面的代碼會介紹
- 當前 segmentShift 的值爲 32 – 4 = 28,segmentMask 爲 16 – 1 = 15,姑且把它們簡單翻譯爲移位數和掩碼,這兩個值馬上就會用到
put 過程分析
我們先看 put 的主流程,對於其中的一些關鍵細節操作,後面會進行詳細介紹。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
|
第一層皮很簡單,根據 hash 值很快就能找到相應的 Segment,之後就是 Segment 內部的 put 操作了。
Segment 內部是由 數組+鏈表 組成的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
|
整體流程還是比較簡單的,由於有獨佔鎖的保護,所以 segment 內部的操作並不複雜。至於這裏面的併發問題,我們稍後再進行介紹。
到這裏 put 操作就結束了,接下來,我們說一說其中幾步關鍵的操作。
初始化槽: ensureSegment
ConcurrentHashMap 初始化的時候會初始化第一個槽 segment[0],對於其他槽來說,在插入第一個值的時候進行初始化。
這裏需要考慮併發,因爲很可能會有多個線程同時進來初始化同一個槽 segment[k],不過只要有一個成功了就可以。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
|
總的來說,ensureSegment(int k) 比較簡單,對於併發操作使用 CAS 進行控制。
我沒搞懂這裏爲什麼要搞一個 while 循環,CAS 失敗不就代表有其他線程成功了嗎,爲什麼要再進行判斷?
獲取寫入鎖: scanAndLockForPut
前面我們看到,在往某個 segment 中 put 的時候,首先會調用 node = tryLock() ? null : scanAndLockForPut(key, hash, value),也就是說先進行一次 tryLock() 快速獲取該 segment 的獨佔鎖,如果失敗,那麼進入到 scanAndLockForPut 這個方法來獲取鎖。
下面我們來具體分析這個方法中是怎麼控制加鎖的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
|
這個方法有兩個出口,一個是 tryLock() 成功了,循環終止,另一個就是重試次數超過了 MAX_SCAN_RETRIES,進到 lock() 方法,此方法會阻塞等待,直到成功拿到獨佔鎖。
這個方法就是看似複雜,但是其實就是做了一件事,那就是獲取該 segment 的獨佔鎖,如果需要的話順便實例化了一下 node。
擴容: rehash
重複一下,segment 數組不能擴容,擴容是 segment 數組某個位置內部的數組 HashEntry\[] 進行擴容,擴容後,容量爲原來的 2 倍。
首先,我們要回顧一下觸發擴容的地方,put 的時候,如果判斷該值的插入會導致該 segment 的元素個數超過閾值,那麼先進行擴容,再插值,讀者這個時候可以回去 put 方法看一眼。
該方法不需要考慮併發,因爲到這裏的時候,是持有該 segment 的獨佔鎖的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
|
這裏的擴容比之前的 HashMap 要複雜一些,代碼難懂一點。上面有兩個挨着的 for 循環,第一個 for 有什麼用呢?
仔細一看發現,如果沒有第一個 for 循環,也是可以工作的,但是,這個 for 循環下來,如果 lastRun 的後面還有比較多的節點,那麼這次就是值得的。因爲我們只需要克隆 lastRun 前面的節點,後面的一串節點跟着 lastRun 走就是了,不需要做任何操作。
我覺得 Doug Lea 的這個想法也是挺有意思的,不過比較壞的情況就是每次 lastRun 都是鏈表的最後一個元素或者很靠後的元素,那麼這次遍歷就有點浪費了。不過 Doug Lea 也說了,根據統計,如果使用默認的閾值,大約只有 1/6 的節點需要克隆。
get 過程分析
相對於 put 來說,get 真的不要太簡單。
- 計算 hash 值,找到 segment 數組中的具體位置,或我們前面用的“槽”
- 槽中也是一個數組,根據 hash 找到數組中具體的位置
- 到這裏是鏈表了,順着鏈表進行查找即可
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
|
併發問題分析
現在我們已經說完了 put 過程和 get 過程,我們可以看到 get 過程中是沒有加鎖的,那自然我們就需要去考慮併發問題。
添加節點的操作 put 和刪除節點的操作 remove 都是要加 segment 上的獨佔鎖的,所以它們之間自然不會有問題,我們需要考慮的問題就是 get 的時候在同一個 segment 中發生了 put 或 remove 操作。
- put 操作的線程安全性。
- 初始化槽,這個我們之前就說過了,使用了 CAS 來初始化 Segment 中的數組。
- 添加節點到鏈表的操作是插入到表頭的,所以,如果這個時候 get 操作在鏈表遍歷的過程已經到了中間,是不會影響的。當然,另一個併發問題就是 get 操作在 put 之後,需要保證剛剛插入表頭的節點被讀取,這個依賴於 setEntryAt 方法中使用的 UNSAFE.putOrderedObject。
- 擴容。擴容是新創建了數組,然後進行遷移數據,最後面將 newTable 設置給屬性 table。所以,如果 get 操作此時也在進行,那麼也沒關係,如果 get 先行,那麼就是在舊的 table 上做查詢操作;而 put 先行,那麼 put 操作的可見性保證就是 table 使用了 volatile 關鍵字。
- remove 操作的線程安全性。
remove 操作我們沒有分析源碼,所以這裏說的讀者感興趣的話還是需要到源碼中去求實一下的。
get 操作需要遍歷鏈表,但是 remove 操作會”破壞”鏈表。
如果 remove 破壞的節點 get 操作已經過去了,那麼這裏不存在任何問題。
如果 remove 先破壞了一個節點,分兩種情況考慮。 1、如果此節點是頭結點,那麼需要將頭結點的 next 設置爲數組該位置的元素,table 雖然使用了 volatile 修飾,但是 volatile 並不能提供數組內部操作的可見性保證,所以源碼中使用了 UNSAFE 來操作數組,請看方法 setEntryAt。2、如果要刪除的節點不是頭結點,它會將要刪除節點的後繼節點接到前驅節點中,這裏的併發保證就是 next 屬性是 volatile 的。
Java8 HashMap
Java8 對 HashMap 進行了一些修改,最大的不同就是利用了紅黑樹,所以其由 數組+鏈表+紅黑樹 組成。
根據 Java7 HashMap 的介紹,我們知道,查找的時候,根據 hash 值我們能夠快速定位到數組的具體下標,但是之後的話,需要順着鏈表一個個比較下去才能找到我們需要的,時間複雜度取決於鏈表的長度,爲 O(n)。
爲了降低這部分的開銷,在 Java8 中,當鏈表中的元素超過了 8 個以後,會將鏈表轉換爲紅黑樹,在這些位置進行查找的時候可以降低時間複雜度爲 O(logN)。
來一張圖簡單示意一下吧:
注意,上圖是示意圖,主要是描述結構,不會達到這個狀態的,因爲這麼多數據的時候早就擴容了。
下面,我們還是用代碼來介紹吧,個人感覺,Java8 的源碼可讀性要差一些,不過精簡一些。
Java7 中使用 Entry 來代表每個 HashMap 中的數據節點,Java8 中使用 Node,基本沒有區別,都是 key,value,hash 和 next 這四個屬性,不過,Node 只能用於鏈表的情況,紅黑樹的情況需要使用 TreeNode。
我們根據數組元素中,第一個節點數據類型是 Node 還是 TreeNode 來判斷該位置下是鏈表還是紅黑樹的。
put 過程分析
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
|
和 Java7 稍微有點不一樣的地方就是,Java7 是先擴容後插入新值的,Java8 先插值再擴容,不過這個不重要。
數組擴容
resize() 方法用於初始化數組或數組擴容,每次擴容後,容量爲原來的 2 倍,並進行數據遷移。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 |
|
get 過程分析
相對於 put 來說,get 真的太簡單了。
- 計算 key 的 hash 值,根據 hash 值找到對應數組下標: hash & (length-1)
- 判斷數組該位置處的元素是否剛好就是我們要找的,如果不是,走第三步
- 判斷該元素類型是否是 TreeNode,如果是,用紅黑樹的方法取數據,如果不是,走第四步
- 遍歷鏈表,直到找到相等(==或equals)的 key
1 2 3 4 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
|
Java8 ConcurrentHashMap
Java7 中實現的 ConcurrentHashMap 說實話還是比較複雜的,Java8 對 ConcurrentHashMap 進行了比較大的改動。建議讀者可以參考 Java8 中 HashMap 相對於 Java7 HashMap 的改動,對於 ConcurrentHashMap,Java8 也引入了紅黑樹。
說實話,Java8 ConcurrentHashMap 源碼真心不簡單,最難的在於擴容,數據遷移操作不容易看懂。
我們先用一個示意圖來描述下其結構:
結構上和 Java8 的 HashMap 基本上一樣,不過它要保證線程安全性,所以在源碼上確實要複雜一些。
初始化
1 2 3 4 5 6 7 8 9 10 11 |
|
這個初始化方法有點意思,通過提供初始容量,計算了 sizeCtl,sizeCtl = 【 (1.5 * initialCapacity + 1),然後向上取最近的 2 的 n 次方】。如 initialCapacity 爲 10,那麼得到 sizeCtl 爲 16,如果 initialCapacity 爲 11,得到 sizeCtl 爲 32。
sizeCtl 這個屬性使用的場景很多,不過只要跟着文章的思路來,就不會被它搞暈了。
如果你愛折騰,也可以看下另一個有三個參數的構造方法,這裏我就不說了,大部分時候,我們會使用無參構造函數進行實例化,我們也按照這個思路來進行源碼分析吧。
put 過程分析
仔細地一行一行代碼看下去:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
|
put 的主流程看完了,但是至少留下了幾個問題,第一個是初始化,第二個是擴容,第三個是幫助數據遷移,這些我們都會在後面進行一一介紹。
初始化數組:initTable
這個比較簡單,主要就是初始化一個合適大小的數組,然後會設置 sizeCtl。
初始化方法中的併發問題是通過對 sizeCtl 進行一個 CAS 操作來控制的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
|
鏈表轉紅黑樹: treeifyBin
前面我們在 put 源碼分析也說過,treeifyBin 不一定就會進行紅黑樹轉換,也可能是僅僅做數組擴容。我們還是進行源碼分析吧。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
|
擴容:tryPresize
如果說 Java8 ConcurrentHashMap 的源碼不簡單,那麼說的就是擴容操作和遷移操作。
這個方法要完完全全看懂還需要看之後的 transfer 方法,讀者應該提前知道這點。
這裏的擴容也是做翻倍擴容的,擴容後數組容量爲原來的 2 倍。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
|
這個方法的核心在於 sizeCtl 值的操作,首先將其設置爲一個負數,然後執行 transfer(tab, null),再下一個循環將 sizeCtl 加 1,並執行 transfer(tab, nt),之後可能是繼續 sizeCtl 加 1,並執行 transfer(tab, nt)。
所以,可能的操作就是執行 1 次 transfer(tab, null) + 多次 transfer(tab, nt),這裏怎麼結束循環的需要看完 transfer 源碼才清楚。
數據遷移:transfer
下面這個方法很點長,將原來的 tab 數組的元素遷移到新的 nextTab 數組中。
雖然我們之前說的 tryPresize 方法中多次調用 transfer 不涉及多線程,但是這個 transfer 方法可以在其他地方被調用,典型地,我們之前在說 put 方法的時候就說過了,請往上看 put 方法,是不是有個地方調用了 helpTransfer 方法,helpTransfer 方法會調用 transfer 方法的。
此方法支持多線程執行,外圍調用此方法的時候,會保證第一個發起數據遷移的線程,nextTab 參數爲 null,之後再調用此方法的時候,nextTab 不會爲 null。
閱讀源碼之前,先要理解併發操作的機制。原數組長度爲 n,所以我們有 n 個遷移任務,讓每個線程每次負責一個小任務是最簡單的,每做完一個任務再檢測是否有其他沒做完的任務,幫助遷移就可以了,而 Doug Lea 使用了一個 stride,簡單理解就是步長,每個線程每次負責遷移其中的一部分,如每次遷移 16 個小任務。所以,我們就需要一個全局的調度者來安排哪個線程執行哪幾個任務,這個就是屬性 transferIndex 的作用。
第一個發起數據遷移的線程會將 transferIndex 指向原數組最後的位置,然後從後往前的 stride 個任務屬於第一個線程,然後將 transferIndex 指向新的位置,再往前的 stride 個任務屬於第二個線程,依此類推。當然,這裏說的第二個線程不是真的一定指代了第二個線程,也可以是同一個線程,這個讀者應該能理解吧。其實就是將一個大的遷移任務分爲了一個個任務包。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 |
|
說到底,transfer 這個方法並沒有實現所有的遷移任務,每次調用這個方法只實現了 transferIndex 往前 stride 個位置的遷移工作,其他的需要由外圍來控制。
這個時候,再回去仔細看 tryPresize 方法可能就會更加清晰一些了。
get 過程分析
get 方法從來都是最簡單的,這裏也不例外:
- 計算 hash 值
- 根據 hash 值找到數組對應位置: (n – 1) & h
- 根據該位置處結點性質進行相應查找
- 如果該位置爲 null,那麼直接返回 null 就可以了
- 如果該位置處的節點剛好就是我們需要的,返回該節點的值即可
- 如果該位置節點的 hash 值小於 0,說明正在擴容,或者是紅黑樹,後面我們再介紹 find 方法
- 如果以上 3 條都不滿足,那就是鏈表,進行遍歷比對即可
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
|
簡單說一句,此方法的大部分內容都很簡單,只有正好碰到擴容的情況,ForwardingNode.find(int h, Object k) 稍微複雜一些,不過在瞭解了數據遷移的過程後,這個也就不難了,所以限於篇幅這裏也不展開說了。
總結
其實也不是很難嘛,雖然沒有像之前的 AQS 和線程池一樣一行一行源碼進行分析,但還是把所有初學者可能會糊塗的地方都進行了深入的介紹,只要是稍微有點基礎的讀者,應該是很容易就能看懂 HashMap 和 ConcurrentHashMap 源碼了。
看源碼不算是目的吧,深入地瞭解 Doug Lea 的設計思路,我覺得還挺有趣的,大師就是大師,代碼寫得真的是好啊。
我發現很多人都以爲我寫博客主要是源碼分析,說真的,我對於源碼分析沒有那麼大熱情,主要都是爲了用源碼說事罷了,可能之後的文章還是會有比較多的源碼分析成分,大家該怎麼看就怎麼看吧。
不要臉地自以爲本文的質量還是挺高的,信息量比較大,如果你覺得有寫得不好的地方,或者說看完本文你還是沒看懂它們,那麼請提出來~~~