Java8 ConcurrentHashMap實現原理,基本和Java8的HashMap相同,不同於他的是前者保證了線程的安全性,和Java7的ConcurrentHashMap區別在於,兩者保證線程安全性的機理不同,Java7中採用了“分段”鎖的概念,每一個分段都有一把鎖,鎖內存儲的着數據,鎖的個數在初始化之後不能擴容,Java7 ConcurrentHashMap原理 傳送門
但是Java8摒棄了這種設計理念,和Java8一樣採用數組+鏈表+紅黑樹的概念來實現,那麼要保證是線程安全(synchronized+CAS)的,所以比起Java8的HashMap,代碼更加的複雜...
數據結構和Java8HashMap基本雷同
字段和成員
/* ---------------- 部分常量-------------- */
/**
* 最大容量,默認是2的30次方
*/
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默認容量是2的4次方
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* 最大的數組大小
*/
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 併發級別
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 負載因子
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 鏈表達到8個元素時會切換程紅黑樹結構
*/
static final int TREEIFY_THRESHOLD = 8;
/* ---------------- 部分字段-------------- */
/**
* 默認爲null,初始化發生在第一次插入操作,默認大小爲16的數組,
* 用來存儲Node節點數據,擴容時大小總是2的冪次方
*/
transient volatile Node<K,V>[] table;
/**
* 默認爲null,擴容時新生成的數組,其大小爲原數組的兩倍
*/
private transient volatile Node<K,V>[] nextTable;
/**
* 基計數器值,主要用於無爭用時
*/
private transient volatile long baseCount;
/**
* 默認爲0,用來控制table的初始化和擴容操作
* -1: table正在初始化
* -N:有N-1個線程正在進行擴容操作
* 0:table沒有被初始化
* 正數:表示初始化或者是下一次進行擴容的大小
*/
private transient volatile int sizeCtl;
/**
* 調整大小時要分割的下一個表索引(加1)。
*/
private transient volatile int transferIndex;
/**
* 自旋鎖(通過CAS鎖定)在調整大小和/或創建反單元格時使用.
*/
private transient volatile int cellsBusy;
/**
* 計數器單元表。當非空時,大小是2的乘方
*/
private transient volatile CounterCell[] counterCells;
數據存儲結構
結構1、採用是的是Node內部類
每一個類都持有next的引用,實際就是鏈表的結構
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
結構2、採用是的TreeNode內部類,繼承了Node
這就是紅黑樹了
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left; //左節點
TreeNode<K,V> right; //右節點
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next,
TreeNode<K,V> parent) {
super(hash, key, val, next);
this.parent = parent;
}
結構3、內部類TreeBin 同樣繼承了Node,在轉換成紅黑樹的時候使用
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root;
volatile TreeNode<K,V> first;
volatile Thread waiter;
volatile int lockState;
// values for lockState
static final int WRITER = 1; // set while holding write lock
static final int WAITER = 2; // set when waiting for write lock
static final int READER = 4; // increment value for setting read lock
初始化方法
//默認無參構造
public ConcurrentHashMap() {
}
//指定初始化大小
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
//指定初始化大小和負載因子
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
//指定初始化容量、負載因子、並行級別
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
//有初始元素的初始化
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
計算閾值與HashMap中一致
//結果爲2的冪次方,大於且最靠近指定的值
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;
}
複製所有的元素:
putAll()
public void putAll(Map<? extends K, ? extends V> m) {
tryPresize(m.size());//擴容
//循環複製元素
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putVal(e.getKey(), e.getValue(), false);
}
擴容:擴容的容量是原來容量的兩倍
tryPresize()
// 首先要說明的是,方法參數 size 傳進來的時候就已經翻了倍了
private final void tryPresize(int size) {
// c:size 的 1.5 倍,再加 1,再往上取最近的 2 的 n 次方。
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
// 這個 if 分支和之前說的初始化數組的代碼基本上是一樣的,在這裏,我們可以不用管這塊代碼
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2); // 0.75 * n
}
} finally {
sizeCtl = sc;
}
}
}
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) {
// 我沒看懂 rs 的真正含義是什麼,不過也關係不大
int rs = resizeStamp(n);
if (sc < 0) {
Node<K,V>[] nt;
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 2. 用 CAS 將 sizeCtl 加 1,然後執行 transfer 方法
// 此時 nextTab 不爲 null
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 1. 將 sizeCtl 設置爲 (rs << RESIZE_STAMP_SHIFT) + 2)
// 我是沒看懂這個值真正的意義是什麼?不過可以計算出來的是,結果是一個比較大的負數
// 調用 transfer 方法,此時 nextTab 參數爲 null
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);//具體的擴容後面說
}
}
}
put() 過程
public V put(K key, V value) {
return putVal(key, value, false);//實際真正執行的方法
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
//由此可以得出不支持null鍵和null值
if (key == null || value == null) throw new NullPointerException();
// 計算hash 值
int hash = spread(key.hashCode());
// 用於記錄相應鏈表的長度
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果數組"空",進行數組初始化
if (tab == null || (n = tab.length) == 0)
// 初始化數組
tab = initTable();
// 找該 hash 值對應的數組下標,得到第一個節點 f
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果數組該位置爲空,
//用一次CAS操作將這個新值放入其中即可,這個put操作差不多就結束了,可以拉到最後面了
// 如果 CAS 失敗,那就是有併發操作,進到下一個循環就好了
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// hash 居然可以等於 MOVED,這個需要到後面才能看明白,不過從名字上也能猜到,肯定是因爲在擴容
else if ((fh = f.hash) == MOVED)
// 幫助數據遷移,這個等到看完數據遷移部分的介紹後,再理解這個就很簡單了
tab = helpTransfer(tab, f);
else { // 到這裏就是說,f 是該位置的頭結點,而且不爲空
V oldVal = null;
// 數組首節點加鎖處理
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) { // 頭結點的 hash 值大於 0,說明是鏈表
// 用於累加,記錄鏈表的長度
binCount = 1;
// 遍歷鏈表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果發現了"相等"的 key,判斷是否要進行值覆蓋,然後也就可以 break 了
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
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) {
// 判斷是否要將鏈表轉換爲紅黑樹,臨界值和 HashMap 一樣,也是 8
if (binCount >= TREEIFY_THRESHOLD)
// 這個方法和 HashMap 中稍微有一點點不同,那就是它不是一定會進行紅黑樹轉換,
// 如果當前數組的長度小於 64,那麼會選擇進行數組擴容,而不是轉換爲紅黑樹
// 具體源碼我們就不看了,擴容部分後面說
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
//
addCount(1L, binCount);
return null;
}
初始化數組:
initTable():併發問題是通過CAS操控sizeCtl變量實現的
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// sizeCtl小於0,說明正在被其他線程初始化,進來的線程都會讓出當前CPU執行權
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// CAS 一下,將 sizeCtl 設置爲 -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;
// 初始化數組,長度爲 16 或初始化時提供的長度
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// 將這個數組賦值給 table,table 是 volatile 的
table = tab = nt;
// 如果 n 爲 16 的話,那麼這裏 sc = 12
// 其實就是 0.75 * n
sc = n - (n >>> 2);
}
} finally {
// 設置 sizeCtl 爲 sc,我們就當是 12 吧
sizeCtl = sc;
}
break;
}
}
return tab;
}
幫助數據遷移
//將舊的數組中的元素複製到新的數組中
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
//舊數組不爲空且nextTable也不空的情況下才能複製
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//cas操作保證線程安全
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);//調用擴容方法
break;
}
}
return nextTab;
}
return table;
}
具體擴容
transfer()
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride 在單核下直接等於 n,多核模式下爲 (n>>>3)/NCPU,最小值是 16
// stride 可以理解爲”步長“,有 n 個位置是需要進行遷移的,
// 將這 n 個任務分爲多個任務包,每個任務包有 stride 個任務
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 如果 nextTab 爲 null,先進行一次初始化
// 前面我們說了,外圍會保證第一個發起遷移的線程調用此方法時,參數 nextTab 爲 null
// 之後參與遷移的線程調用此方法時,nextTab 不會爲 null
if (nextTab == null) {
try {
// 容量翻倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
// nextTable 是 ConcurrentHashMap 中的屬性
nextTable = nextTab;
// transferIndex 也是 ConcurrentHashMap 的屬性,用於控制遷移的位置
transferIndex = n;
}
int nextn = nextTab.length;
// ForwardingNode 翻譯過來就是正在被遷移的 Node
// 這個構造方法會生成一個Node,key、value 和 next 都爲 null,關鍵是 hash 爲 MOVED
// 後面我們會看到,原數組中位置 i 處的節點完成遷移工作後,
// 就會將位置 i 處設置爲這個 ForwardingNode,用來告訴其他線程該位置已經處理過了
// 所以它其實相當於是一個標誌。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// advance 指的是做完了一個位置的遷移工作,可以準備做下一個位置的了
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
/*
* 下面這個 for 循環,最難理解的在前面,而要看懂它們,應該先看懂後面的,然後再倒回來看
*
*/
// i 是位置索引,bound 是邊界,注意是從後往前
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 下面這個 while 真的是不好理解
// advance 爲 true 表示可以進行下一個位置的遷移了
// 簡單理解結局:i 指向了 transferIndex,bound 指向了 transferIndex-stride
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
// 將 transferIndex 值賦給 nextIndex
// 這裏 transferIndex 一旦小於等於 0,說明原數組的所有位置都有相應的線程去處理了
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// 看括號中的代碼,nextBound 是這次遷移任務的邊界,注意,是從後往前
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
// 所有的遷移操作已經完成
nextTable = null;
// 將新的 nextTab 賦值給 table 屬性,完成遷移
table = nextTab;
// 重新計算 sizeCtl:n 是原數組長度,所以 sizeCtl 得出的值將是新數組長度的 0.75 倍
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 之前我們說過,sizeCtl 在遷移前會設置爲 (rs << RESIZE_STAMP_SHIFT) + 2
// 然後,每有一個線程參與遷移就會將 sizeCtl 加 1,
// 這裏使用 CAS 操作對 sizeCtl 進行減 1,代表做完了屬於自己的任務
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 任務結束,方法退出
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 到這裏,說明 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT,
// 也就是說,所有的遷移任務都做完了,也就會進入到上面的 if(finishing){} 分支了
finishing = advance = true;
i = n; // recheck before commit
}
}
// 如果位置 i 處是空的,沒有任何節點,那麼放入剛剛初始化的 ForwardingNode ”空節點“
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 該位置處是一個 ForwardingNode,代表該位置已經遷移過了
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 對數組該位置處的結點加鎖,開始處理數組該位置處的遷移工作
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// 頭結點的 hash 大於 0,說明是鏈表的 Node 節點
if (fh >= 0) {
// 下面這一塊和 Java7 中的 ConcurrentHashMap 遷移是差不多的,
// 需要將鏈表一分爲二,
// 找到原鏈表中的 lastRun,然後 lastRun 及其之後的節點是一起進行遷移的
// lastRun 之前的節點需要進行克隆,然後分到兩個鏈表中
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 其中的一個鏈表放在新數組的位置 i
setTabAt(nextTab, i, ln);
// 另一個鏈表放在新數組的位置 i+n
setTabAt(nextTab, i + n, hn);
// 將原數組該位置處設置爲 fwd,代表該位置已經處理完畢,
// 其他線程一旦看到該位置的 hash 值爲 MOVED,就不會進行遷移了
setTabAt(tab, i, fwd);
// advance 設置爲 true,代表該位置已經遷移完畢
advance = true;
}
else if (f instanceof TreeBin) {
// 紅黑樹的遷移
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
// 如果一分爲二後,節點數少於 8,那麼將紅黑樹轉換回鏈表
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
// 將 ln 放置在新數組的位置 i
setTabAt(nextTab, i, ln);
// 將 hn 放置在新數組的位置 i+n
setTabAt(nextTab, i + n, hn);
// 將原數組該位置處設置爲 fwd,代表該位置已經處理完畢,
// 其他線程一旦看到該位置的 hash 值爲 MOVED,就不會進行遷移了
setTabAt(tab, i, fwd);
// advance 設置爲 true,代表該位置已經遷移完畢
advance = true;
}
}
}
}
}
}
鏈表轉紅黑樹: treeifyBin
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
// MIN_TREEIFY_CAPACITY 爲 64
// 所以,如果數組長度小於 64 的時候,其實也就是 32 或者 16 或者更小的時候,會進行數組擴容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 後面我們再詳細分析這個方法
tryPresize(n << 1);
// b 是頭結點
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 加鎖
synchronized (b) {
if (tabAt(tab, index) == b) {
// 下面就是遍歷鏈表,建立一顆紅黑樹
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
new TreeNode<K,V>(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
// 將紅黑樹設置到數組相應位置中
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
數據加入成功計算數組的大小
addCount()
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
//更新baseCount,table的數量,counterCells表示元素個數的變化
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
//如果多個線程都在執行,則CAS失敗,執行fullAddCount,全部加入count
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
//是否需要進行擴容
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);//具體擴容
s = sumCount();
}
}
}
獲取數據
get()
- 計算 hash 值
- 根據 hash 值找到數組對應位置: (n - 1) & h
- 根據該位置處結點性質進行相應查找
- 如果該位置爲 null,那麼直接返回 null 就可以了
- 如果該位置處的節點剛好就是我們需要的,返回該節點的值即可
- 如果該位置節點的 hash 值小於 0,說明正在擴容,或者是紅黑樹,後面我們再介紹 find 方法
- 如果以上 3 條都不滿足,那就是鏈表,進行遍歷比對即可
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 判斷頭結點是否就是我們需要的節點
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// 如果頭結點的 hash 小於 0,說明 正在擴容,或者該位置是紅黑樹
else if (eh < 0)
// 參考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k)
return (p = e.find(h, key)) != null ? p.val : null;
// 遍歷鏈表
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
總結:其中擴容的部分還有些不是很爛,還是需要記錄並多看幾次,看的多了就理解了當時大神的設計理念,路漫漫其修遠兮,吾將上下而求索...