摘要:需要注意的是所鏈接的是一顆紅黑樹,紅黑樹的結(jié)點(diǎn)用表示,所以中實(shí)際上一共有五種不同類型的結(jié)點(diǎn)。時(shí)不再延續(xù),轉(zhuǎn)而直接對每個(gè)桶加鎖,并用紅黑樹鏈接沖突結(jié)點(diǎn)。
本文首發(fā)于一世流云專欄:https://segmentfault.com/blog...一、ConcurrentHashMap類簡介
ConcurrentHashMap是在JDK1.5時(shí),J.U.C引入的一個(gè)同步集合工具類,顧名思義,這是一個(gè)線程安全的HashMap。不同版本的ConcurrentHashMap,內(nèi)部實(shí)現(xiàn)機(jī)制千差萬別,本節(jié)所有的討論基于JDK1.8。
ConcurrentHashMap的類繼承關(guān)系并不復(fù)雜:
可以看到ConcurrentHashMap繼承了AbstractMap,這是一個(gè)java.util包下的抽象類,提供Map接口的骨干實(shí)現(xiàn),以最大限度地減少實(shí)現(xiàn)Map這類數(shù)據(jù)結(jié)構(gòu)時(shí)所需的工作量,一般來講,如果需要重復(fù)造輪子——自己來實(shí)現(xiàn)一個(gè)Map,那一般就是繼承AbstractMap。
另外,ConcurrentHashMap實(shí)現(xiàn)了ConcurrentMap這個(gè)接口,ConcurrentMap是在JDK1.5時(shí)隨著J.U.C包引入的,這個(gè)接口其實(shí)就是提供了一些針對Map的原子操作:
ConcurrentMap接口提供的功能:
方法簽名 | 功能 |
---|---|
getOrDefault(Object key, V defaultValue) | 返回指定key對應(yīng)的值;如果Map不存在該key,則返回defaultValue |
forEach(BiConsumer action) | 遍歷Map的所有Entry,并對其進(jìn)行指定的aciton操作 |
putIfAbsent(K key, V value) | 如果Map不存在指定的key,則插入 |
remove(Object key, Object value) | 刪除與 |
replace(K key, V oldValue, V newValue) | 如果存在key,且值和oldValue一致,則更新為newValue,并返回true;否則,返回false |
replace(K key, V value) | 如果存在key,則更新為value,返回舊value;否則,返回null |
replaceAll(BiFunction function) | 遍歷Map的所有Entry,并對其進(jìn)行指定的funtion操作 |
computeIfAbsent(K key, Function mappingFunction) | 如果Map不存在指定的key,則通過mappingFunction計(jì)算value并插入 |
computeIfPresent(K key, BiFunction remappingFunction) | 如果Map存在指定的key,則通過mappingFunction計(jì)算value并替換舊值 |
compute(K key, BiFunction remappingFunction) | 根據(jù)指定的key,查找value;然后根據(jù)得到的value和remappingFunction重新計(jì)算新值,并替換舊值 |
merge(K key, V value, BiFunction remappingFunction) | 如果key不存在,則插入value;否則,根據(jù)key對應(yīng)的值和remappingFunction計(jì)算新值,并替換舊值 |
我們先來看下ConcurrentHashMap對象的內(nèi)部結(jié)構(gòu)究竟什么樣的:
基本結(jié)構(gòu)ConcurrentHashMap內(nèi)部維護(hù)了一個(gè)Node類型的數(shù)組,也就是table:
transient volatile Node
數(shù)組的每一個(gè)位置table[i]代表了一個(gè)桶,當(dāng)插入鍵值對時(shí),會(huì)根據(jù)鍵的hash值映射到不同的桶位置,table一共可以包含4種不同類型的桶:Node、TreeBin、ForwardingNode、ReservationNode。上圖中,不同的桶用不同顏色表示。可以看到,有的桶鏈接著鏈表,有的桶鏈接著樹,這也是JDK1.8中ConcurrentHashMap的特殊之處,后面會(huì)詳細(xì)講到。
需要注意的是:TreeBin所鏈接的是一顆紅黑樹,紅黑樹的結(jié)點(diǎn)用TreeNode表示,所以ConcurrentHashMap中實(shí)際上一共有五種不同類型的Node結(jié)點(diǎn)。
之所以用TreeBin而不是直接用TreeNode,是因?yàn)榧t黑樹的操作比較復(fù)雜,包括構(gòu)建、左旋、右旋、刪除,平衡等操作,用一個(gè)代理結(jié)點(diǎn)TreeBin來包含這些復(fù)雜操作,其實(shí)是一種“職責(zé)分離”的思想。另外TreeBin中也包含了一些加/解鎖的操作。
在JDK1.8之前,ConcurrentHashMap采用了分段鎖的設(shè)計(jì)思路,以減少熱點(diǎn)域的沖突。JDK1.8時(shí)不再延續(xù),轉(zhuǎn)而直接對每個(gè)桶加鎖,并用“紅黑樹”鏈接沖突結(jié)點(diǎn)。關(guān)于紅黑樹和一般HashMap的實(shí)現(xiàn)思路,讀者可以參考《Algorithms 4th》,或我之前寫的博文:紅黑樹 和 哈希表,本文不會(huì)對紅黑樹的相關(guān)操作具體分析。結(jié)點(diǎn)定義
上一節(jié)提到,ConcurrentHashMap一共包含5種結(jié)點(diǎn),我們來看下各個(gè)結(jié)點(diǎn)的定義和作用。
1、Node結(jié)點(diǎn)
Node結(jié)點(diǎn)的定義非常簡單,也是其它四種類型結(jié)點(diǎn)的父類。
默認(rèn)鏈接到table[i]——桶上的結(jié)點(diǎn)就是Node結(jié)點(diǎn)。
當(dāng)出現(xiàn)hash沖突時(shí),Node結(jié)點(diǎn)會(huì)首先以鏈表的形式鏈接到table上,當(dāng)結(jié)點(diǎn)數(shù)量超過一定數(shù)目時(shí),鏈表會(huì)轉(zhuǎn)化為紅黑樹。因?yàn)殒湵聿檎业钠骄鶗r(shí)間復(fù)雜度為O(n),而紅黑樹是一種平衡二叉樹,其平均時(shí)間復(fù)雜度為O(logn)。
/** * 普通的Entry結(jié)點(diǎn), 以鏈表形式保存時(shí)才會(huì)使用, 存儲(chǔ)實(shí)際的數(shù)據(jù). */ static class Nodeimplements Map.Entry { final int hash; final K key; volatile V val; volatile Node next; // 鏈表指針 Node(int hash, K key, V val, Node next) { this.hash = hash; this.key = key; this.val = val; this.next = next; } public final K getKey() { return key; } public final V getValue() { return val; } public final int hashCode() { return key.hashCode() ^ val.hashCode(); } public final String toString() { return key + "=" + val; } public final V setValue(V value) { throw new UnsupportedOperationException(); } public final boolean equals(Object o) { Object k, v, u; Map.Entry, ?> e; return ((o instanceof Map.Entry) && (k = (e = (Map.Entry, ?>) o).getKey()) != null && (v = e.getValue()) != null && (k == key || k.equals(key)) && (v == (u = val) || v.equals(u))); } /** * 鏈表查找. */ Node find(int h, Object k) { Node e = this; if (k != null) { do { K ek; if (e.hash == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; } while ((e = e.next) != null); } return null; } }
2、TreeNode結(jié)點(diǎn)
TreeNode就是紅黑樹的結(jié)點(diǎn),TreeNode不會(huì)直接鏈接到table[i]——桶上面,而是由TreeBin鏈接,TreeBin會(huì)指向紅黑樹的根結(jié)點(diǎn)。
/** * 紅黑樹結(jié)點(diǎn), 存儲(chǔ)實(shí)際的數(shù)據(jù). */ static final class TreeNodeextends Node { boolean red; TreeNode parent; TreeNode left; TreeNode right; /** * prev指針是為了方便刪除. * 刪除鏈表的非頭結(jié)點(diǎn)時(shí),需要知道它的前驅(qū)結(jié)點(diǎn)才能刪除,所以直接提供一個(gè)prev指針 */ TreeNode prev; TreeNode(int hash, K key, V val, Node next, TreeNode parent) { super(hash, key, val, next); this.parent = parent; } Node find(int h, Object k) { return findTreeNode(h, k, null); } /** * 以當(dāng)前結(jié)點(diǎn)(this)為根結(jié)點(diǎn),開始遍歷查找指定key. */ final TreeNode findTreeNode(int h, Object k, Class> kc) { if (k != null) { TreeNode p = this; do { int ph, dir; K pk; TreeNode q; TreeNode pl = p.left, pr = p.right; if ((ph = p.hash) > h) p = pl; else if (ph < h) p = pr; else if ((pk = p.key) == k || (pk != null && k.equals(pk))) return p; else if (pl == null) p = pr; else if (pr == null) p = pl; else if ((kc != null || (kc = comparableClassFor(k)) != null) && (dir = compareComparables(kc, k, pk)) != 0) p = (dir < 0) ? pl : pr; else if ((q = pr.findTreeNode(h, k, kc)) != null) return q; else p = pl; } while (p != null); } return null; } }
3、TreeBin結(jié)點(diǎn)
TreeBin相當(dāng)于TreeNode的代理結(jié)點(diǎn)。TreeBin會(huì)直接鏈接到table[i]——桶上面,該結(jié)點(diǎn)提供了一系列紅黑樹相關(guān)的操作,以及加鎖、解鎖操作。
/** * TreeNode的代理結(jié)點(diǎn)(相當(dāng)于封裝了TreeNode的容器,提供針對紅黑樹的轉(zhuǎn)換操作和鎖控制) * hash值固定為-3 */ static final class TreeBinextends Node { TreeNode root; // 紅黑樹結(jié)構(gòu)的根結(jié)點(diǎn) volatile TreeNode first; // 鏈表結(jié)構(gòu)的頭結(jié)點(diǎn) volatile Thread waiter; // 最近的一個(gè)設(shè)置WAITER標(biāo)識位的線程 volatile int lockState; // 整體的鎖狀態(tài)標(biāo)識位 static final int WRITER = 1; // 二進(jìn)制001,紅黑樹的寫鎖狀態(tài) static final int WAITER = 2; // 二進(jìn)制010,紅黑樹的等待獲取寫鎖狀態(tài) static final int READER = 4; // 二進(jìn)制100,紅黑樹的讀鎖狀態(tài),讀可以并發(fā),每多一個(gè)讀線程,lockState都加上一個(gè)READER值 /** * 在hashCode相等并且不是Comparable類型時(shí),用此方法判斷大小. */ static int tieBreakOrder(Object a, Object b) { int d; if (a == null || b == null || (d = a.getClass().getName(). compareTo(b.getClass().getName())) == 0) d = (System.identityHashCode(a) <= System.identityHashCode(b) ? -1 : 1); return d; } /** * 將以b為頭結(jié)點(diǎn)的鏈表轉(zhuǎn)換為紅黑樹. */ TreeBin(TreeNode b) { super(TREEBIN, null, null, null); this.first = b; TreeNode r = null; for (TreeNode x = b, next; x != null; x = next) { next = (TreeNode ) 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 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 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); } /** * 對紅黑樹的根結(jié)點(diǎn)加寫鎖. */ private final void lockRoot() { if (!U.compareAndSwapInt(this, LOCKSTATE, 0, WRITER)) contendedLock(); } /** * 釋放寫鎖. */ private final void unlockRoot() { lockState = 0; } /** * Possibly blocks awaiting root lock. */ private final void contendedLock() { boolean waiting = false; for (int s; ; ) { if (((s = lockState) & ~WAITER) == 0) { if (U.compareAndSwapInt(this, LOCKSTATE, s, WRITER)) { if (waiting) waiter = null; return; } } else if ((s & WAITER) == 0) { if (U.compareAndSwapInt(this, LOCKSTATE, s, s | WAITER)) { waiting = true; waiter = Thread.currentThread(); } } else if (waiting) LockSupport.park(this); } } /** * 從根結(jié)點(diǎn)開始遍歷查找,找到“相等”的結(jié)點(diǎn)就返回它,沒找到就返回null * 當(dāng)存在寫鎖時(shí),以鏈表方式進(jìn)行查找 */ final Node find(int h, Object k) { if (k != null) { for (Node e = first; e != null; ) { int s; K ek; /** * 兩種特殊情況下以鏈表的方式進(jìn)行查找: * 1. 有線程正持有寫鎖,這樣做能夠不阻塞讀線程 * 2. 有線程等待獲取寫鎖,不再繼續(xù)加讀鎖,相當(dāng)于“寫優(yōu)先”模式 */ if (((s = lockState) & (WAITER | WRITER)) != 0) { if (e.hash == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; e = e.next; } else if (U.compareAndSwapInt(this, LOCKSTATE, s, s + READER)) { TreeNode r, p; try { p = ((r = root) == null ? null : r.findTreeNode(h, k, null)); } finally { Thread w; if (U.getAndAddInt(this, LOCKSTATE, -READER) == (READER | WAITER) && (w = waiter) != null) LockSupport.unpark(w); } return p; } } } return null; } /** * 查找指定key對應(yīng)的結(jié)點(diǎn),如果未找到,則插入. * * @return 插入成功返回null, 否則返回找到的結(jié)點(diǎn) */ final TreeNode putTreeVal(int h, K k, V v) { Class> kc = null; boolean searched = false; for (TreeNode p = root; ; ) { int dir, ph; K pk; if (p == null) { first = root = new TreeNode (h, k, v, null, null); break; } else if ((ph = p.hash) > h) dir = -1; else if (ph < h) dir = 1; else if ((pk = p.key) == k || (pk != null && k.equals(pk))) return p; else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0) { if (!searched) { TreeNode q, ch; searched = true; if (((ch = p.left) != null && (q = ch.findTreeNode(h, k, kc)) != null) || ((ch = p.right) != null && (q = ch.findTreeNode(h, k, kc)) != null)) return q; } dir = tieBreakOrder(k, pk); } TreeNode xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { TreeNode x, f = first; first = x = new TreeNode (h, k, v, f, xp); if (f != null) f.prev = x; if (dir <= 0) xp.left = x; else xp.right = x; if (!xp.red) x.red = true; else { lockRoot(); try { root = balanceInsertion(root, x); } finally { unlockRoot(); } } break; } } assert checkInvariants(root); return null; } /** * 刪除紅黑樹的結(jié)點(diǎn): * 1. 紅黑樹規(guī)模太小時(shí),返回true,然后進(jìn)行 樹 -> 鏈表 的轉(zhuǎn)化; * 2. 紅黑樹規(guī)模足夠時(shí),不用變換成鏈表,但刪除結(jié)點(diǎn)時(shí)需要加寫鎖. */ final boolean removeTreeNode(TreeNode p) { TreeNode next = (TreeNode ) p.next; TreeNode pred = p.prev; // unlink traversal pointers TreeNode r, rl; if (pred == null) first = next; else pred.next = next; if (next != null) next.prev = pred; if (first == null) { root = null; return true; } if ((r = root) == null || r.right == null || // too small (rl = r.left) == null || rl.left == null) return true; lockRoot(); try { TreeNode replacement; TreeNode pl = p.left; TreeNode pr = p.right; if (pl != null && pr != null) { TreeNode s = pr, sl; while ((sl = s.left) != null) // find successor s = sl; boolean c = s.red; s.red = p.red; p.red = c; // swap colors TreeNode sr = s.right; TreeNode pp = p.parent; if (s == pr) { // p was s"s direct parent p.parent = s; s.right = p; } else { TreeNode sp = s.parent; if ((p.parent = sp) != null) { if (s == sp.left) sp.left = p; else sp.right = p; } if ((s.right = pr) != null) pr.parent = s; } p.left = null; if ((p.right = sr) != null) sr.parent = p; if ((s.left = pl) != null) pl.parent = s; if ((s.parent = pp) == null) r = s; else if (p == pp.left) pp.left = s; else pp.right = s; if (sr != null) replacement = sr; else replacement = p; } else if (pl != null) replacement = pl; else if (pr != null) replacement = pr; else replacement = p; if (replacement != p) { TreeNode pp = replacement.parent = p.parent; if (pp == null) r = replacement; else if (p == pp.left) pp.left = replacement; else pp.right = replacement; p.left = p.right = p.parent = null; } root = (p.red) ? r : balanceDeletion(r, replacement); if (p == replacement) { // detach pointers TreeNode pp; if ((pp = p.parent) != null) { if (p == pp.left) pp.left = null; else if (p == pp.right) pp.right = null; p.parent = null; } } } finally { unlockRoot(); } assert checkInvariants(root); return false; } // 以下是紅黑樹的經(jīng)典操作方法,改編自《算法導(dǎo)論》 static TreeNode rotateLeft(TreeNode root, TreeNode p) { TreeNode r, pp, rl; if (p != null && (r = p.right) != null) { if ((rl = p.right = r.left) != null) rl.parent = p; if ((pp = r.parent = p.parent) == null) (root = r).red = false; else if (pp.left == p) pp.left = r; else pp.right = r; r.left = p; p.parent = r; } return root; } static TreeNode rotateRight(TreeNode root, TreeNode p) { TreeNode l, pp, lr; if (p != null && (l = p.left) != null) { if ((lr = p.left = l.right) != null) lr.parent = p; if ((pp = l.parent = p.parent) == null) (root = l).red = false; else if (pp.right == p) pp.right = l; else pp.left = l; l.right = p; p.parent = l; } return root; } static TreeNode balanceInsertion(TreeNode root, TreeNode x) { x.red = true; for (TreeNode xp, xpp, xppl, xppr; ; ) { if ((xp = x.parent) == null) { x.red = false; return x; } else if (!xp.red || (xpp = xp.parent) == null) return root; if (xp == (xppl = xpp.left)) { if ((xppr = xpp.right) != null && xppr.red) { xppr.red = false; xp.red = false; xpp.red = true; x = xpp; } else { if (x == xp.right) { root = rotateLeft(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; } if (xp != null) { xp.red = false; if (xpp != null) { xpp.red = true; root = rotateRight(root, xpp); } } } } else { if (xppl != null && xppl.red) { xppl.red = false; xp.red = false; xpp.red = true; x = xpp; } else { if (x == xp.left) { root = rotateRight(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; } if (xp != null) { xp.red = false; if (xpp != null) { xpp.red = true; root = rotateLeft(root, xpp); } } } } } } static TreeNode balanceDeletion(TreeNode root, TreeNode x) { for (TreeNode xp, xpl, xpr; ; ) { if (x == null || x == root) return root; else if ((xp = x.parent) == null) { x.red = false; return x; } else if (x.red) { x.red = false; return root; } else if ((xpl = xp.left) == x) { if ((xpr = xp.right) != null && xpr.red) { xpr.red = false; xp.red = true; root = rotateLeft(root, xp); xpr = (xp = x.parent) == null ? null : xp.right; } if (xpr == null) x = xp; else { TreeNode sl = xpr.left, sr = xpr.right; if ((sr == null || !sr.red) && (sl == null || !sl.red)) { xpr.red = true; x = xp; } else { if (sr == null || !sr.red) { if (sl != null) sl.red = false; xpr.red = true; root = rotateRight(root, xpr); xpr = (xp = x.parent) == null ? null : xp.right; } if (xpr != null) { xpr.red = (xp == null) ? false : xp.red; if ((sr = xpr.right) != null) sr.red = false; } if (xp != null) { xp.red = false; root = rotateLeft(root, xp); } x = root; } } } else { // symmetric if (xpl != null && xpl.red) { xpl.red = false; xp.red = true; root = rotateRight(root, xp); xpl = (xp = x.parent) == null ? null : xp.left; } if (xpl == null) x = xp; else { TreeNode sl = xpl.left, sr = xpl.right; if ((sl == null || !sl.red) && (sr == null || !sr.red)) { xpl.red = true; x = xp; } else { if (sl == null || !sl.red) { if (sr != null) sr.red = false; xpl.red = true; root = rotateLeft(root, xpl); xpl = (xp = x.parent) == null ? null : xp.left; } if (xpl != null) { xpl.red = (xp == null) ? false : xp.red; if ((sl = xpl.left) != null) sl.red = false; } if (xp != null) { xp.red = false; root = rotateRight(root, xp); } x = root; } } } } } /** * 遞歸檢查紅黑樹的正確性 */ static boolean checkInvariants(TreeNode t) { TreeNode tp = t.parent, tl = t.left, tr = t.right, tb = t.prev, tn = (TreeNode ) t.next; if (tb != null && tb.next != t) return false; if (tn != null && tn.prev != t) return false; if (tp != null && t != tp.left && t != tp.right) return false; if (tl != null && (tl.parent != t || tl.hash > t.hash)) return false; if (tr != null && (tr.parent != t || tr.hash < t.hash)) return false; if (t.red && tl != null && tl.red && tr != null && tr.red) return false; if (tl != null && !checkInvariants(tl)) return false; if (tr != null && !checkInvariants(tr)) return false; return true; } private static final sun.misc.Unsafe U; private static final long LOCKSTATE; static { try { U = sun.misc.Unsafe.getUnsafe(); Class> k = TreeBin.class; LOCKSTATE = U.objectFieldOffset (k.getDeclaredField("lockState")); } catch (Exception e) { throw new Error(e); } } }
4、ForwardingNode結(jié)點(diǎn)
ForwardingNode結(jié)點(diǎn)僅僅在擴(kuò)容時(shí)才會(huì)使用——關(guān)于擴(kuò)容,會(huì)在下一篇文章專門論述
/** * ForwardingNode是一種臨時(shí)結(jié)點(diǎn),在擴(kuò)容進(jìn)行中才會(huì)出現(xiàn),hash值固定為-1,且不存儲(chǔ)實(shí)際數(shù)據(jù)。 * 如果舊table數(shù)組的一個(gè)hash桶中全部的結(jié)點(diǎn)都遷移到了新table中,則在這個(gè)桶中放置一個(gè)ForwardingNode。 * 讀操作碰到ForwardingNode時(shí),將操作轉(zhuǎn)發(fā)到擴(kuò)容后的新table數(shù)組上去執(zhí)行;寫操作碰見它時(shí),則嘗試幫助擴(kuò)容。 */ static final class ForwardingNodeextends Node { final Node [] nextTable; ForwardingNode(Node [] tab) { super(MOVED, null, null, null); this.nextTable = tab; } // 在新的數(shù)組nextTable上進(jìn)行查找 Node find(int h, Object k) { // loop to avoid arbitrarily deep recursion on forwarding nodes outer: for (Node [] tab = nextTable; ; ) { Node e; int n; if (k == null || tab == null || (n = tab.length) == 0 || (e = tabAt(tab, (n - 1) & h)) == null) return null; for (; ; ) { int eh; K ek; if ((eh = e.hash) == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; if (eh < 0) { if (e instanceof ForwardingNode) { tab = ((ForwardingNode ) e).nextTable; continue outer; } else return e.find(h, k); } if ((e = e.next) == null) return null; } } } }
5、ReservationNode結(jié)點(diǎn)
保留結(jié)點(diǎn),ConcurrentHashMap中的一些特殊方法會(huì)專門用到該類結(jié)點(diǎn)。
/** * 保留結(jié)點(diǎn). * hash值固定為-3, 不保存實(shí)際數(shù)據(jù) * 只在computeIfAbsent和compute這兩個(gè)函數(shù)式API中充當(dāng)占位符加鎖使用 */ static final class ReservationNode三、ConcurrentHashMap的構(gòu)造 構(gòu)造器定義extends Node { ReservationNode() { super(RESERVED, null, null, null); } Node find(int h, Object k) { return null; } }
ConcurrentHashMap提供了五個(gè)構(gòu)造器,這五個(gè)構(gòu)造器內(nèi)部最多也只是計(jì)算了下table的初始容量大小,并沒有進(jìn)行實(shí)際的創(chuàng)建table數(shù)組的工作:
ConcurrentHashMap,采用了一種“懶加載”的模式,只有到首次插入鍵值對的時(shí)候,才會(huì)真正的去初始化table數(shù)組。
空構(gòu)造器
public ConcurrentHashMap() { }
指定table初始容量的構(gòu)造器
/** * 指定table初始容量的構(gòu)造器. * tableSizeFor會(huì)返回大于入?yún)ⅲ╥nitialCapacity + (initialCapacity >>> 1) + 1)的最小2次冪值 */ 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; }
根據(jù)已有的Map構(gòu)造
/** * 根據(jù)已有的Map構(gòu)造ConcurrentHashMap. */ public ConcurrentHashMap(Map extends K, ? extends V> m) { this.sizeCtl = DEFAULT_CAPACITY; putAll(m); }
指定table初始容量和負(fù)載因子的構(gòu)造器
/** * 指定table初始容量和負(fù)載因子的構(gòu)造器. */ public ConcurrentHashMap(int initialCapacity, float loadFactor) { this(initialCapacity, loadFactor, 1); }
指定table初始容量、負(fù)載因子、并發(fā)級別的構(gòu)造器
/** * 指定table初始容量、負(fù)載因子、并發(fā)級別的構(gòu)造器. *常量/字段定義* 注意:concurrencyLevel只是為了兼容JDK1.8以前的版本,并不是實(shí)際的并發(fā)級別,loadFactor也不是實(shí)際的負(fù)載因子 * 這兩個(gè)都失去了原有的意義,僅僅對初始容量有一定的控制作用 */ public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) { if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) throw new IllegalArgumentException(); if (initialCapacity < concurrencyLevel) initialCapacity = concurrencyLevel; long size = (long) (1.0 + (long) initialCapacity / loadFactor); int cap = (size >= (long) MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int) size); this.sizeCtl = cap; }
我們再看下ConcurrentHashMap內(nèi)部定義了哪些常量/字段,先大致熟悉下這些常量/字段,后面結(jié)合具體的方法分析就能相對容易地理解這些常量/字段的含義了。
常量 :
/** * 最大容量. */ private static final int MAXIMUM_CAPACITY = 1 << 30; /** * 默認(rèn)初始容量 */ private static final int DEFAULT_CAPACITY = 16; /** * The largest possible (non-power of two) array size. * Needed by toArray and related methods. */ static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; /** * 負(fù)載因子,為了兼容JDK1.8以前的版本而保留。 * JDK1.8中的ConcurrentHashMap的負(fù)載因子恒定為0.75 */ private static final float LOAD_FACTOR = 0.75f; /** * 鏈表轉(zhuǎn)樹的閾值,即鏈接結(jié)點(diǎn)數(shù)大于8時(shí), 鏈表轉(zhuǎn)換為樹. */ static final int TREEIFY_THRESHOLD = 8; /** * 樹轉(zhuǎn)鏈表的閾值,即樹結(jié)點(diǎn)樹小于6時(shí),樹轉(zhuǎn)換為鏈表. */ static final int UNTREEIFY_THRESHOLD = 6; /** * 在鏈表轉(zhuǎn)變成樹之前,還會(huì)有一次判斷: * 即只有鍵值對數(shù)量大于MIN_TREEIFY_CAPACITY,才會(huì)發(fā)生轉(zhuǎn)換。 * 這是為了避免在Table建立初期,多個(gè)鍵值對恰好被放入了同一個(gè)鏈表中而導(dǎo)致不必要的轉(zhuǎn)化。 */ static final int MIN_TREEIFY_CAPACITY = 64; /** * 在樹轉(zhuǎn)變成鏈表之前,還會(huì)有一次判斷: * 即只有鍵值對數(shù)量小于MIN_TRANSFER_STRIDE,才會(huì)發(fā)生轉(zhuǎn)換. */ private static final int MIN_TRANSFER_STRIDE = 16; /** * 用于在擴(kuò)容時(shí)生成唯一的隨機(jī)數(shù). */ private static int RESIZE_STAMP_BITS = 16; /** * 可同時(shí)進(jìn)行擴(kuò)容操作的最大線程數(shù). */ private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1; /** * The bit shift for recording size stamp in sizeCtl. */ private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS; static final int MOVED = -1; // 標(biāo)識ForwardingNode結(jié)點(diǎn)(在擴(kuò)容時(shí)才會(huì)出現(xiàn),不存儲(chǔ)實(shí)際數(shù)據(jù)) static final int TREEBIN = -2; // 標(biāo)識紅黑樹的根結(jié)點(diǎn) static final int RESERVED = -3; // 標(biāo)識ReservationNode結(jié)點(diǎn)() static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash /** * CPU核心數(shù),擴(kuò)容時(shí)使用 */ static final int NCPU = Runtime.getRuntime().availableProcessors();
字段 :
/** * Node數(shù)組,標(biāo)識整個(gè)Map,首次插入元素時(shí)創(chuàng)建,大小總是2的冪次. */ transient volatile Node四、ConcurrentHashMap的put操作[] table; /** * 擴(kuò)容后的新Node數(shù)組,只有在擴(kuò)容時(shí)才非空. */ private transient volatile Node [] nextTable; /** * 控制table的初始化和擴(kuò)容. * 0 : 初始默認(rèn)值 * -1 : 有線程正在進(jìn)行table的初始化 * >0 : table初始化時(shí)使用的容量,或初始化/擴(kuò)容完成后的threshold * -(1 + nThreads) : 記錄正在執(zhí)行擴(kuò)容任務(wù)的線程數(shù) */ private transient volatile int sizeCtl; /** * 擴(kuò)容時(shí)需要用到的一個(gè)下標(biāo)變量. */ private transient volatile int transferIndex; /** * 計(jì)數(shù)基值,當(dāng)沒有線程競爭時(shí),計(jì)數(shù)將加到該變量上。類似于LongAdder的base變量 */ private transient volatile long baseCount; /** * 計(jì)數(shù)數(shù)組,出現(xiàn)并發(fā)沖突時(shí)使用。類似于LongAdder的cells數(shù)組 */ private transient volatile CounterCell[] counterCells; /** * 自旋標(biāo)識位,用于CounterCell[]擴(kuò)容時(shí)使用。類似于LongAdder的cellsBusy變量 */ private transient volatile int cellsBusy; // 視圖相關(guān)字段 private transient KeySetView keySet; private transient ValuesView values; private transient EntrySetView entrySet;
我們來看下ConcurrentHashMap如何插入一個(gè)元素:
/** * 插入鍵值對,均不能為null. */ public V put(K key, V value) { return putVal(key, value, false); }
put方法內(nèi)部調(diào)用了putVal這個(gè)私有方法:
/** * 實(shí)際的插入操作 * * @param onlyIfAbsent true:僅當(dāng)key不存在時(shí),才插入 */ final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); // 再次計(jì)算hash值 /** * 使用鏈表保存時(shí),binCount記錄table[i]這個(gè)桶中所保存的結(jié)點(diǎn)數(shù); * 使用紅黑樹保存時(shí),binCount==2,保證put后更改計(jì)數(shù)值時(shí)能夠進(jìn)行擴(kuò)容檢查,同時(shí)不觸發(fā)紅黑樹化操作 */ int binCount = 0; for (Node[] tab = table; ; ) { // 自旋插入結(jié)點(diǎn),直到成功 Node f; int n, i, fh; if (tab == null || (n = tab.length) == 0) // CASE1: 首次初始化table —— 懶加載 tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // CASE2: table[i]對應(yīng)的桶為null // 注意下上面table[i]的索引i的計(jì)算方式:[ key的hash值 & (table.length-1) ] // 這也是table容量必須為2的冪次的原因,讀者可以自己看下當(dāng)table.length為2的冪次時(shí),(table.length-1)的二進(jìn)制形式的特點(diǎn) —— 全是1 // 配合這種索引計(jì)算方式可以實(shí)現(xiàn)key的均勻分布,減少hash沖突 if (casTabAt(tab, i, null, new Node (hash, key, value, null))) // 插入一個(gè)鏈表結(jié)點(diǎn) break; } else if ((fh = f.hash) == MOVED) // CASE3: 發(fā)現(xiàn)ForwardingNode結(jié)點(diǎn),說明此時(shí)table正在擴(kuò)容,則嘗試協(xié)助數(shù)據(jù)遷移 tab = helpTransfer(tab, f); else { // CASE4: 出現(xiàn)hash沖突,也就是table[i]桶中已經(jīng)有了結(jié)點(diǎn) V oldVal = null; synchronized (f) { // 鎖住table[i]結(jié)點(diǎn) if (tabAt(tab, i) == f) { // 再判斷一下table[i]是不是第一個(gè)結(jié)點(diǎn), 防止其它線程的寫修改 if (fh >= 0) { // CASE4.1: table[i]是鏈表結(jié)點(diǎn) binCount = 1; for (Node e = f; ; ++binCount) { K ek; // 找到“相等”的結(jié)點(diǎn),判斷是否需要更新value值 if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { oldVal = e.val; if (!onlyIfAbsent) e.val = value; break; } Node pred = e; if ((e = e.next) == null) { // “尾插法”插入新結(jié)點(diǎn) pred.next = new Node (hash, key, value, null); break; } } } else if (f instanceof TreeBin) { // CASE4.2: table[i]是紅黑樹結(jié)點(diǎn) Node p; binCount = 2; if ((p = ((TreeBin ) f).putTreeVal(hash, key, value)) != null) { oldVal = p.val; if (!onlyIfAbsent) p.val = value; } } } } if (binCount != 0) { if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); // 鏈表 -> 紅黑樹 轉(zhuǎn)換 if (oldVal != null) // 表明本次put操作只是替換了舊值,不用更改計(jì)數(shù)值 return oldVal; break; } } } addCount(1L, binCount); // 計(jì)數(shù)值加1 return null; }
putVal的邏輯還是很清晰的,首先根據(jù)key計(jì)算hash值,然后通過hash值與table容量進(jìn)行運(yùn)算,計(jì)算得到key所映射的索引——也就是對應(yīng)到table中桶的位置。
這里需要注意的是計(jì)算索引的方式:i = (n - 1) & hash
n - 1 == table.length - 1,table.length 的大小必須為2的冪次的原因就在這里。
讀者可以自己計(jì)算下,當(dāng)table.length為2的冪次時(shí),(table.length-1)的二進(jìn)制形式的特點(diǎn)是除最高位外全部是1,配合這種索引計(jì)算方式可以實(shí)現(xiàn)key在table中的均勻分布,減少hash沖突——出現(xiàn)hash沖突時(shí),結(jié)點(diǎn)就需要以鏈表或紅黑樹的形式鏈接到table[i],這樣無論是插入還是查找都需要額外的時(shí)間。
putVal方法一共處理四種情況:
1、首次初始化table —— 懶加載之前講構(gòu)造器的時(shí)候說了,ConcurrentHashMap在構(gòu)造的時(shí)候并不會(huì)初始化table數(shù)組,首次初始化就在這里通過initTable方法完成:
/** * 初始化table, 使用sizeCtl作為初始化容量. */ private final Node[] initTable() { Node [] tab; int sc; while ((tab = table) == null || tab.length == 0) { //自旋直到初始化成功 if ((sc = sizeCtl) < 0) // sizeCtl<0 說明table已經(jīng)正在初始化/擴(kuò)容 Thread.yield(); else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { // 將sizeCtl更新成-1,表示正在初始化中 try { if ((tab = table) == null || tab.length == 0) { int n = (sc > 0) ? sc : DEFAULT_CAPACITY; Node [] nt = (Node []) new Node, ?>[n]; table = tab = nt; sc = n - (n >>> 2); // n - (n >>> 2) = n - n/4 = 0.75n, 前面說了loadFactor已在JDK1.8廢棄 } } finally { sizeCtl = sc; // 設(shè)置threshold = 0.75 * table.length } break; } } return tab; }
initTable方法就是將sizeCtl字段的值(ConcurrentHashMap對象在構(gòu)造時(shí)設(shè)置)作為table的大小。
需要注意的是這里的n - (n >>> 2),其實(shí)就是0.75 * n,sizeCtl 的值最終需要變更為0.75 * n,相當(dāng)于設(shè)置了threshold。
最簡單的情況,直接CAS操作占用桶table[i]即可。
3、發(fā)現(xiàn)ForwardingNode結(jié)點(diǎn),說明此時(shí)table正在擴(kuò)容,則嘗試協(xié)助進(jìn)行數(shù)據(jù)遷移ForwardingNode結(jié)點(diǎn)是ConcurrentHashMap中的五類結(jié)點(diǎn)之一,相當(dāng)于一個(gè)占位結(jié)點(diǎn),表示當(dāng)前table正在進(jìn)行擴(kuò)容,當(dāng)前線程可以嘗試協(xié)助數(shù)據(jù)遷移。
擴(kuò)容和數(shù)據(jù)遷移是ConcurrentHashMap中最復(fù)雜的部分,我們會(huì)在下一章專門討論。4、出現(xiàn)hash沖突,也就是table[i]桶中已經(jīng)有了結(jié)點(diǎn)
當(dāng)兩個(gè)不同key映射到同一個(gè)table[i]桶中時(shí),就會(huì)出現(xiàn)這種情況:
當(dāng)table[i]的結(jié)點(diǎn)類型為Node——鏈表結(jié)點(diǎn)時(shí),就會(huì)將新結(jié)點(diǎn)以“尾插法”的形式插入鏈表的尾部。
當(dāng)table[i]的結(jié)點(diǎn)類型為TreeBin——紅黑樹代理結(jié)點(diǎn)時(shí),就會(huì)將新結(jié)點(diǎn)通過紅黑樹的插入方式插入。
putVal方法的最后,涉及將鏈表轉(zhuǎn)換為紅黑樹 —— treeifyBin ,但實(shí)際情況并非立即就會(huì)轉(zhuǎn)換,當(dāng)table的容量小于64時(shí),出于性能考慮,只是對table數(shù)組擴(kuò)容1倍——tryPresize:
tryPresize方法涉及擴(kuò)容和數(shù)據(jù)遷移,我們會(huì)在下一章專門討論。
/** * 嘗試進(jìn)行 鏈表 -> 紅黑樹 的轉(zhuǎn)換. */ private final void treeifyBin(Node五、ConcurrentHashMap的get操作[] tab, int index) { Node b; int n, sc; if (tab != null) { // CASE 1: table的容量 < MIN_TREEIFY_CAPACITY(64)時(shí),直接進(jìn)行table擴(kuò)容,不進(jìn)行紅黑樹轉(zhuǎn)換 if ((n = tab.length) < MIN_TREEIFY_CAPACITY) tryPresize(n << 1); // CASE 2: table的容量 ≥ MIN_TREEIFY_CAPACITY(64)時(shí),進(jìn)行鏈表 -> 紅黑樹的轉(zhuǎn)換 else if ((b = tabAt(tab, index)) != null && b.hash >= 0) { synchronized (b) { if (tabAt(tab, index) == b) { TreeNode hd = null, tl = null; // 遍歷鏈表,建立紅黑樹 for (Node e = b; e != null; e = e.next) { TreeNode p = new TreeNode (e.hash, e.key, e.val, null, null); if ((p.prev = tl) == null) hd = p; else tl.next = p; tl = p; } // 以TreeBin類型包裝,并鏈接到table[index]中 setTabAt(tab, index, new TreeBin (hd)); } } } } }
我們來看下ConcurrentHashMap如何根據(jù)key來查找一個(gè)元素:
/** * 根據(jù)key查找對應(yīng)的value值 * * @return 查找不到則返回null * @throws NullPointerException if the specified key is null */ public V get(Object key) { Node[] tab; Node e, p; int n, eh; K ek; int h = spread(key.hashCode()); // 重新計(jì)算key的hash值 if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) { if ((eh = e.hash) == h) { // table[i]就是待查找的項(xiàng),直接返回 if ((ek = e.key) == key || (ek != null && key.equals(ek))) return e.val; } else if (eh < 0) // hash值<0, 說明遇到特殊結(jié)點(diǎn)(非鏈表結(jié)點(diǎn)), 調(diào)用find方法查找 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; }
get方法的邏輯很簡單,首先根據(jù)key的hash值計(jì)算映射到table的哪個(gè)桶——table[i]。
如果table[i]的key和待查找key相同,那直接返回;
如果table[i]對應(yīng)的結(jié)點(diǎn)是特殊結(jié)點(diǎn)(hash值小于0),則通過find方法查找;
如果table[i]對應(yīng)的結(jié)點(diǎn)是普通鏈表結(jié)點(diǎn),則按鏈表方式查找。
關(guān)鍵是第二種情況,不同結(jié)點(diǎn)的find查找方式有所不同,我們來具體看下:
Node結(jié)點(diǎn)的查找當(dāng)槽table[i]被普通Node結(jié)點(diǎn)占用,說明是鏈表鏈接的形式,直接從鏈表頭開始查找:
/** * 鏈表查找. */ NodeTreeBin結(jié)點(diǎn)的查找find(int h, Object k) { Node e = this; if (k != null) { do { K ek; if (e.hash == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; } while ((e = e.next) != null); } return null; }
TreeBin的查找比較特殊,我們知道當(dāng)槽table[i]被TreeBin結(jié)點(diǎn)占用時(shí),說明鏈接的是一棵紅黑樹。由于紅黑樹的插入、刪除會(huì)涉及整個(gè)結(jié)構(gòu)的調(diào)整,所以通常存在讀寫并發(fā)操作的時(shí)候,是需要加鎖的。
ConcurrentHashMap采用了一種類似讀寫鎖的方式:當(dāng)線程持有寫鎖(修改紅黑樹)時(shí),如果讀線程需要查找,不會(huì)像傳統(tǒng)的讀寫鎖那樣阻塞等待,而是轉(zhuǎn)而以鏈表的形式進(jìn)行查找(TreeBin本身時(shí)Node類型的子類,所有擁有Node的所有字段)
/** * 從根結(jié)點(diǎn)開始遍歷查找,找到“相等”的結(jié)點(diǎn)就返回它,沒找到就返回null * 當(dāng)存在寫鎖時(shí),以鏈表方式進(jìn)行查找 */ final NodeForwardingNode結(jié)點(diǎn)的查找find(int h, Object k) { if (k != null) { for (Node e = first; e != null; ) { int s; K ek; /** * 兩種特殊情況下以鏈表的方式進(jìn)行查找: * 1. 有線程正持有寫鎖,這樣做能夠不阻塞讀線程 * 2. 有線程等待獲取寫鎖,不再繼續(xù)加讀鎖,相當(dāng)于“寫優(yōu)先”模式 */ if (((s = lockState) & (WAITER | WRITER)) != 0) { if (e.hash == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; e = e.next; // 鏈表形式 } // 讀線程數(shù)量加1,讀狀態(tài)進(jìn)行累加 else if (U.compareAndSwapInt(this, LOCKSTATE, s, s + READER)) { TreeNode r, p; try { p = ((r = root) == null ? null : r.findTreeNode(h, k, null)); } finally { Thread w; // 如果當(dāng)前線程是最后一個(gè)讀線程,且有寫線程因?yàn)樽x鎖而阻塞,則寫線程,告訴它可以嘗試獲取寫鎖了 if (U.getAndAddInt(this, LOCKSTATE, -READER) == (READER | WAITER) && (w = waiter) != null) LockSupport.unpark(w); } return p; } } } return null; }
ForwardingNode是一種臨時(shí)結(jié)點(diǎn),在擴(kuò)容進(jìn)行中才會(huì)出現(xiàn),所以查找也在擴(kuò)容的table上進(jìn)行:
/** * 在新的擴(kuò)容table——nextTable上進(jìn)行查找 */ NodeReservationNode結(jié)點(diǎn)的查找find(int h, Object k) { // loop to avoid arbitrarily deep recursion on forwarding nodes outer: for (Node [] tab = nextTable; ; ) { Node e; int n; if (k == null || tab == null || (n = tab.length) == 0 || (e = tabAt(tab, (n - 1) & h)) == null) return null; for (; ; ) { int eh; K ek; if ((eh = e.hash) == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; if (eh < 0) { if (e instanceof ForwardingNode) { tab = ((ForwardingNode ) e).nextTable; continue outer; } else return e.find(h, k); } if ((e = e.next) == null) return null; } } }
ReservationNode是保留結(jié)點(diǎn),不保存實(shí)際數(shù)據(jù),所以直接返回null:
Node六、ConcurrentHashMap的計(jì)數(shù) 計(jì)數(shù)原理find(int h, Object k) { return null; }
我們來看下ConcurrentHashMap是如何計(jì)算鍵值對的數(shù)目的:
public int size() { long n = sumCount(); return ((n < 0L) ? 0 : (n > (long) Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) n); }
size方法內(nèi)部實(shí)際調(diào)用了sumCount方法:
final long sumCount() { CounterCell[] as = counterCells; CounterCell a; long sum = baseCount; if (as != null) { for (int i = 0; i < as.length; ++i) { if ((a = as[i]) != null) sum += a.value; } } return sum; }
可以看到,最終鍵值對的數(shù)目其實(shí)是通過下面這個(gè)公式計(jì)算的:
$$ sum = baseCount + sum_{i=0}^nCounterCell[i] $$
如果讀者看過我之前的博文——LongAdder,這時(shí)應(yīng)該已經(jīng)猜到ConcurrentHashMap的計(jì)數(shù)思路了。
沒錯(cuò),ConcurrentHashMap的計(jì)數(shù)其實(shí)延用了LongAdder分段計(jì)數(shù)的思路,只不過ConcurrentHashMap并沒有在內(nèi)部直接使用LongAdder,而是差不多copy了一份和LongAdder類似的代碼:
/** * 計(jì)數(shù)基值,當(dāng)沒有線程競爭時(shí),計(jì)數(shù)將加到該變量上。類似于LongAdder的base變量 */ private transient volatile long baseCount; /** * 計(jì)數(shù)數(shù)組,出現(xiàn)并發(fā)沖突時(shí)使用。類似于LongAdder的cells數(shù)組 */ private transient volatile CounterCell[] counterCells; /** * 自旋標(biāo)識位,用于CounterCell[]擴(kuò)容時(shí)使用。類似于LongAdder的cellsBusy變量 */ private transient volatile int cellsBusy;
我們來看下CounterCell這個(gè)槽對象——出現(xiàn)并發(fā)沖突時(shí),每個(gè)線程會(huì)根據(jù)自己的hash值找到對應(yīng)的槽位置:
/** * 計(jì)數(shù)槽. * 類似于LongAdder中的Cell內(nèi)部類 */ static final class CounterCell { volatile long value; CounterCell(long x) { value = x; } }addCount的實(shí)現(xiàn)
回顧之前的putval方法的最后,當(dāng)插入一對鍵值對后,通過addCount方法將計(jì)數(shù)值為加1:
/** * 實(shí)際的插入操作 * * @param onlyIfAbsent true:僅當(dāng)key不存在時(shí),才插入 */ final V putVal(K key, V value, boolean onlyIfAbsent) { // … addCount(1L, binCount); // 計(jì)數(shù)值加1 return null; }
我們來看下addCount的具體實(shí)現(xiàn)(后半部分涉及擴(kuò)容,暫且不看):
首先,如果counterCells為null,說明之前一直沒有出現(xiàn)過沖突,直接將值累加到baseCount上;
否則,嘗試更新counterCells[i]中的值,更新成功就退出。失敗說明槽中也出現(xiàn)了并發(fā)沖突,可能涉及槽數(shù)組——counterCells的擴(kuò)容,所以調(diào)用fullAddCount方法。
fullAddCount的邏輯和LongAdder中的longAccumulate幾乎完全一樣,這里不再贅述,讀者可以參考:Java多線程進(jìn)階(十七)—— J.U.C之a(chǎn)tomic框架:LongAdder
/** * 更改計(jì)數(shù)值 */ private final void addCount(long x, int check) { CounterCell[] as; long b, s; if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { // 首先嘗試更新baseCount ? // 更新失敗,說明出現(xiàn)并發(fā)沖突,則將計(jì)數(shù)值累加到Cell槽 CounterCell a; long v; int m; boolean uncontended = true; if (as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null || // 根據(jù)線程hash值計(jì)算槽索引 !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) { fullAddCount(x, uncontended); // 槽更新也失敗, 則會(huì)執(zhí)行fullAddCount return; } if (check <= 1) return; s = sumCount(); } if (check >= 0) { // 檢測是否擴(kuò)容 Node總結(jié)[] 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(); } } }
本文較為詳細(xì)地分析了ConcurrentHashMap的內(nèi)部結(jié)構(gòu)和典型方法的實(shí)現(xiàn),下一篇將分析ConcurrentHashMap最復(fù)雜的部分——擴(kuò)容/數(shù)據(jù)轉(zhuǎn)移。
文章版權(quán)歸作者所有,未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址:http://specialneedsforspecialkids.com/yun/76823.html
摘要:一擴(kuò)容的基本思路中,最復(fù)雜的部分就是擴(kuò)容數(shù)據(jù)遷移,涉及多線程的合作和。單線程注意這兩種情況都是調(diào)用了方法,通過第二個(gè)入?yún)⑦M(jìn)行區(qū)分表示擴(kuò)容后的新數(shù)組,如果為,表示首次發(fā)起擴(kuò)容。第二種情況下,是通過和移位運(yùn)算來保證僅有一個(gè)線程能發(fā)起擴(kuò)容。 showImg(https://segmentfault.com/img/bVbf0J0?w=1000&h=663); 本文首發(fā)于一世流云專欄:http...
摘要:整個(gè)包,按照功能可以大致劃分如下鎖框架原子類框架同步器框架集合框架執(zhí)行器框架本系列將按上述順序分析,分析所基于的源碼為。后,根據(jù)一系列常見的多線程設(shè)計(jì)模式,設(shè)計(jì)了并發(fā)包,其中包下提供了一系列基礎(chǔ)的鎖工具,用以對等進(jìn)行補(bǔ)充增強(qiáng)。 showImg(https://segmentfault.com/img/remote/1460000016012623); 本文首發(fā)于一世流云專欄:https...
摘要:我們來看下的類繼承圖可以看到,實(shí)現(xiàn)了接口,在多線程進(jìn)階二五之框架中,我們提到過實(shí)現(xiàn)了接口,以提供和排序相關(guān)的功能,維持元素的有序性,所以就是一種為并發(fā)環(huán)境設(shè)計(jì)的有序工具類。唯一的區(qū)別是針對的僅僅是鍵值,針對鍵值對進(jìn)行操作。 showImg(https://segmentfault.com/img/bVbggic?w=960&h=600); 本文首發(fā)于一世流云專欄:https://seg...
摘要:僅僅當(dāng)有多個(gè)線程同時(shí)進(jìn)行寫操作時(shí),才會(huì)進(jìn)行同步。可以看到,上述方法返回一個(gè)迭代器對象,的迭代是在舊數(shù)組上進(jìn)行的,當(dāng)創(chuàng)建迭代器的那一刻就確定了,所以迭代過程中不會(huì)拋出并發(fā)修改異常。另外,迭代器對象也不支持修改方法,全部會(huì)拋出異常。 showImg(https://segmentfault.com/img/bVbggij?w=960&h=600); 本文首發(fā)于一世流云專欄:https://...
摘要:我們之前已經(jīng)介紹過了,底層基于跳表實(shí)現(xiàn),其操作平均時(shí)間復(fù)雜度均為。事實(shí)上,內(nèi)部引用了一個(gè)對象,以組合方式,委托對象實(shí)現(xiàn)了所有功能。線程安全內(nèi)存的使用較多迭代是對快照進(jìn)行的,不會(huì)拋出,且迭代過程中不支持修改操作。 showImg(https://segmentfault.com/img/bVbggjf?w=600&h=377); 本文首發(fā)于一世流云專欄:https://segmentfa...
閱讀 3133·2021-11-19 09:40
閱讀 2430·2021-10-14 09:42
閱讀 1698·2021-09-22 15:34
閱讀 1442·2019-08-30 15:55
閱讀 775·2019-08-29 12:59
閱讀 412·2019-08-28 18:28
閱讀 1818·2019-08-26 13:42
閱讀 1519·2019-08-26 13:29