ConcurreentHashMap的實現原理與使用
ConcurrentHashMap是線程安全且高效的HashMap。
爲什麼要使用ConcurrentHashMap
在併發編程中使用HashMap可能導致程序死循環。而使用線程安全的HashTable效率又非常低下,基於以上兩個原因,便有了ConcurrentHashMap的登場機會。
線程不安全的HashMap
在多線程環境下,使用HashMap進行put操作會引起死循環,導致CPU利用率接近100%,所以在併發情況下不能使用HashMap。
HashMap在併發執行put操作時會引起死循環,是因爲多線程會導致HashMap的Entry鏈表形成環形數據結構,一旦形成環形數據結構,Entry的next節點永遠不爲空,,就會產生死循環獲取Entry。
效率低下的HashTable
HashTable容器使用了synchronized來保證線程安全,但在線程競爭激烈的情況下HashTable的效率非常低下。因爲當一個線程訪問HashTable的同步方法,其他線程也訪問HashTable的同步方法時,會進入阻塞或輪詢狀態。
ConcurrentHashMap的鎖分段技術可有效提升併發訪問率
容器裏有很多把鎖,每一把鎖用於鎖容器中其中一部分數據,那麼當多線程訪問容器裏不同數據段的數據時,線程間就不會存在鎖競爭,從而可以有效提高併發訪問效率,這就是ConcurrentHashMap所使用的鎖分段技術。
ConcurrentHashMap的結構
ConcurrentHashMap是由Segment數組結構和HashEntry數據結構組成。Segment是一種可重入鎖(ReentrantLock),在ConcurrentHashMap裏扮演鎖的角色;HashEntry則用於存儲鍵值對數據。
ConcurrentHashMap的操作
get操作
Segment的get操作實現非常簡單和高效。先經過一次再散列,然後使用這個散列值通過散列運算定位到Segment,再通過散列算法定位到元素:
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;
}
else if (eh < 0)
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;
}
put操作
由於put操作方法裏需要對共享變量進行寫操作,所以爲了線程安全,在操作共享變量時必須加鎖。
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
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();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
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 {
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
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) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
### 是否需要擴容
在插入元素前先會先判斷Segment裏的HashEntry數組是否超過容量(threshold),如果超過閾值,則對數組進行擴容
### 如何擴容
在擴容的時候,首先會創建一個容量是原來容量兩倍的數組,然後對原數組裏的元素進行再散列後插入到新的數組裏。爲了高效,ConcurrentHashMap不會對整個容器進行擴容,而只對某個segment進行擴容。
size操作
如果要統計整個ConcurrentHashMap裏元素的大小,就必須統計所有Segment裏的元素的大小後求和。
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
JDK版本
ConcurrentHashMap源碼分析
- table:默認爲null,初始化發生在第一次插入操作,默認大小爲16的數組,用來存儲Node節點數據,擴容時大小總是2的冪次方。
- nextTable:默認爲null,擴容時新生成的數組,其大小爲原數組的兩倍。
- sizeCtl :默認爲0,用來控制table的初始化和擴容操作,具體應用在後續會體現出來。
- -1 代表table正在初始化
- -N 表示有N-1個線程正在進行擴容操作
- 其餘情況:
1、如果table未初始化,表示table需要初始化的大小。
2、如果table初始化完成,表示table的容量,默認是table大小的0.75倍,居然用這個公式算0.75(n - (n >>> 2))。 - Node:保存key,value及key的hash值的數據結構。
class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
...
}
其中value和next都用volatile修飾,保證併發的可見性。
- ForwardingNode:一個特殊的Node節點,hash值爲-1,其中存儲nextTable的引用。
final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
}
只有table發生擴容的時候,ForwardingNode纔會發揮作用,作爲一個佔位符放在table中表示當前節點爲null或則已經被移動。
實例初始化
實例化ConcurrentHashMap時帶參數時,會根據參數調整table的大小,假設參數爲100,最終會調整成256,確保table的大小總是2的冪次方,算法如下:
ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>(100);
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;
}
注意,ConcurrentHashMap在構造函數中只會初始化sizeCtl值,並不會直接初始化table,而是延緩到第一次put操作。
table初始化
前面已經提到過,table初始化操作會延緩到第一次put行爲。但是put是可以併發執行的,Doug Lea是如何實現table只初始化一次的?讓我們來看看源碼的實現。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
//如果一個線程發現sizeCtl<0,意味着另外的線程執行CAS操作成功,當前線程只需要讓出cpu時間片
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
sizeCtl默認爲0,如果ConcurrentHashMap實例化時有傳參數,sizeCtl會是一個2的冪次方的值。所以執行第一次put操作的線程會執行Unsafe.compareAndSwapInt方法修改sizeCtl爲-1,有且只有一個線程能夠修改成功,其它線程通過Thread.yield()讓出CPU時間片等待table初始化完成。
put操作
假設table已經初始化完成,put操作採用CAS+synchronized實現併發插入或更新操作,具體實現如下。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
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();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
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);
...省略部分代碼
}
addCount(1L, binCount);
return null;
}
- hash算法
static final int spread(int h) {return (h ^ (h >>> 16)) & HASH_BITS;}
- table中定位索引位置,n是table的大小
int index = (n - 1) & hash
- 獲取table中對應索引的元素f。
Doug Lea採用Unsafe.getObjectVolatile來獲取,也許有人質疑,直接table[index]不可以麼,爲什麼要這麼複雜?
在java內存模型中,我們已經知道每個線程都有一個工作內存,裏面存儲着table的副本,雖然table是volatile修飾的,但不能保證線程每次都拿到table中的最新元素,Unsafe.getObjectVolatile可以直接獲取指定內存的數據,保證了每次拿到數據都是最新的。 - 如果f爲null,說明table中這個位置第一次插入元素,利用Unsafe.compareAndSwapObject方法插入Node節點。
- 如果CAS成功,說明Node節點已經插入,隨後addCount(1L, binCount)方法會檢查當前容量是否需要進行擴容。
- 如果CAS失敗,說明有其它線程提前插入了節點,自旋重新嘗試在這個位置插入節點。
- 如果f的hash值爲-1,說明當前f是ForwardingNode節點,意味有其它線程正在擴容,則一起進行擴容操作。
- 其餘情況把新的Node節點按鏈表或紅黑樹的方式插入到合適的位置,這個過程採用同步內置鎖實現併發,代碼如下:
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
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;
}
}
}
}
在節點f上進行同步,節點插入之前,再次利用tabAt(tab, i) == f判斷,防止被其它線程修改。
- 如果f.hash >= 0,說明f是鏈表結構的頭結點,遍歷鏈表,如果找到對應的node節點,則修改value,否則在鏈表尾部加入節點。
- 如果f是TreeBin類型節點,說明f是紅黑樹根節點,則在樹結構上遍歷元素,更新或增加節點。
- 如果鏈表中節點數binCount >= TREEIFY_THRESHOLD(默認是8),則把鏈表轉化爲紅黑樹結構。
table擴容
當table容量不足的時候,即table的元素數量達到容量閾值sizeCtl,需要對table進行擴容。
整個擴容分爲兩部分:
- 構建一個nextTable,大小爲table的兩倍。
- 把table的數據複製到nextTable中。
這兩個過程在單線程下實現很簡單,但是ConcurrentHashMap是支持併發插入的,擴容操作自然也會有併發的出現,這種情況下,第二步可以支持節點的併發複製,這樣性能自然提升不少,但實現的複雜度也上升了一個臺階。
先看第一步,構建nextTable,毫無疑問,這個過程只能只有單個線程進行nextTable的初始化,具體實現如下:
private final void addCount(long x, int check) {
...
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();
}
}
}
通過Unsafe.compareAndSwapInt修改sizeCtl值,保證只有一個線程能夠初始化nextTable,擴容後的數組長度爲原來的兩倍,但是容量是原來的1.5。
節點從table移動到nextTable,大體思想是遍歷、複製的過程。
- 首先根據運算得到需要遍歷的次數i,然後利用tabAt方法獲得i位置的元素f,初始化一個forwardNode實例fwd。
- 如果f == null,則在table中的i位置放入fwd,這個過程是採用Unsafe.compareAndSwapObjectf方法實現的,很巧妙的實現了節點的併發移動。
- 如果f是鏈表的頭節點,就構造一個反序鏈表,把他們分別放在nextTable的i和i+n的位置上,移動完成,採用Unsafe.putObjectVolatile方法給table原位置賦值fwd。
- 如果f是TreeBin節點,也做一個反序處理,並判斷是否需要untreeify,把處理的結果分別放在nextTable的i和i+n的位置上,移動完成,同樣採用Unsafe.putObjectVolatile方法給table原位置賦值fwd。
遍歷過所有的節點以後就完成了複製工作,把table指向nextTable,並更新sizeCtl爲新數組大小的0.75倍 ,擴容完成。
紅黑樹構造
注意:如果鏈表結構中元素超過TREEIFY_THRESHOLD閾值,默認爲8個,則把鏈表轉化爲紅黑樹,提高遍歷查詢效率。
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
接下來我們看看如何構造樹結構,代碼如下:
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
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));
}
}
}
}
}
可以看出,生成樹節點的代碼塊是同步的,進入同步代碼塊之後,再次驗證table中index位置元素是否被修改過。
1、根據table中index位置Node鏈表,重新生成一個hd爲頭結點的TreeNode鏈表。
2、根據hd頭結點,生成TreeBin樹結構,並把樹結構的root節點寫到table的index位置的內存中,具體實現如下:
TreeBin(TreeNode<K,V> b) {
super(TREEBIN, null, null, null);
this.first = b;
TreeNode<K,V> r = null;
for (TreeNode<K,V> x = b, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
if (r == null) {
x.parent = null;
x.red = false;
r = x;
}
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = r;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
r = balanceInsertion(r, x);
break;
}
}
}
}
this.root = r;
assert checkInvariants(root);
}
主要根據Node節點的hash值大小構建二叉樹。這個紅黑樹的構造過程實在有點複雜,感興趣的同學可以看看源碼。
get操作
get操作和put操作相比,顯得簡單了許多。
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;
}
else if (eh < 0)
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;
}
- 判斷table是否爲空,如果爲空,直接返回null。
- 計算key的hash值,並獲取指定table中指定位置的Node節點,通過遍歷鏈表或則樹結構找到對應的節點,返回value值。