![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/08\/20250814061547-689d7f1377d6f.png\")
<\/p>\npublic static void main(String[] args) {
\n demo(
\n \/\/ \u521b\u5efa map \u96c6\u5408，\u4f7f\u7528 ConcurrentHashMap
\n () -> new ConcurrentHashMap<String, Integer>(),<\/p>\n
(map, words) -> {
\n for (String word : words) {
\n Integer counter = map.get(word);
\n int newValue = counter == null ? 1 : counter + 1;
\n map.put(word, newValue);
\n }
\n }
\n );
\n}<\/p>\n
ConcurrentHashMap\u7684\u7ebf\u7a0b\u5b89\u5168\u662f\u6307\u5b83\u6bcf\u4e00\u4e2a\u65b9\u6cd5\u662f\u539f\u5b50\u7684，get\/put\u662f\u539f\u5b50\u7684，\u4f46\u662fget+put\u4e0d\u662f\u539f\u5b50\u7684\u3002<\/p>\n
public static void main(String[] args) {
\n demo(
\n \/\/ \u521b\u5efa ConcurrentHashMap \u7684\u5de5\u5382\u65b9\u6cd5
\n () -> new ConcurrentHashMap<String, Integer>(),<\/p>\n
\/\/ \u5904\u7406 map \u548c words \u7684\u903b\u8f91
\n (map, words) -> {
\n for (String word : words) {
\n \/\/ \u540c\u6b65\u5757，\u9501\u5b9a map \u5bf9\u8c61
\n synchronized (map) {
\n Integer counter = map.get(word);
\n int newValue = counter == null ? 1 : counter + 1;
\n map.put(word, newValue);
\n }
\n }
\n }
\n );
\n}<\/p>\n
\u53ef\u4ee5\u76f4\u63a5\u52a0\u9501\u6765\u4fdd\u8bc1\u591a\u4e2a\u64cd\u4f5c\u7684\u539f\u5b50\u6027，\u4f46\u662f\u5e76\u4e0d\u597d，ConcurrentHashMap\u5e95\u5c42\u662f\u901a\u8fc7\u66f4\u52a0\u7ec6\u7c92\u5ea6\u7684\u9501\u6765\u5b9e\u73b0\u7684，\u76f4\u63a5\u7ed9\u6574\u4e2amap\u52a0\u9501\u5148\u5f53\u4e8e\u76f4\u63a5\u9000\u5316\u4e86，\u5e76\u53d1\u5ea6\u548c\u6027\u80fd\u90fd\u4e0d\u9ad8<\/p>\n
\u89e3\u6cd5：<\/p>\n
public class Main {
\n public static void main(String[] args) {
\n \/\/ \u8c03\u7528 demo \u65b9\u6cd5，\u4f20\u5165\u4e24\u4e2a Lambda \u8868\u8fbe\u5f0f：
\n \/\/ 1. \u7528\u4e8e\u521b\u5efa ConcurrentHashMap \u7684\u5de5\u5382
\n \/\/ 2. \u7528\u4e8e\u5904\u7406 map \u548c words \u7684\u903b\u8f91
\n demo(
\n \/\/ \u521b\u5efa ConcurrentHashMap<String, LongAdder> \u7684\u5de5\u5382\u65b9\u6cd5
\n \/\/ \u5ef6\u8fdf\u521b\u5efa\u96c6\u5408，\u901a\u8fc7 Lambda \u8868\u8fbe\u5f0f\u5c01\u88c5\u521b\u5efa\u903b\u8f91
\n () -> new ConcurrentHashMap<String, LongAdder>(),<\/p>\n
\/\/ \u5904\u7406 map \u548c words \u7684\u903b\u8f91，BiConsumer \u63a5\u6536\u4e24\u4e2a\u53c2\u6570：
\n \/\/ ConcurrentHashMap<String, LongAdder> map \u548c \u5355\u8bcd\u96c6\u5408 words（\u63a8\u6d4b\u4e3a String \u6570\u7ec4\/\u96c6\u5408）
\n (map, words) -> {
\n \/\/ \u904d\u5386\u5355\u8bcd\u96c6\u5408\u4e2d\u7684\u6bcf\u4e2a\u5355\u8bcd
\n for (String word : words) {
\n \/\/ computeIfAbsent \u662f ConcurrentHashMap \u7684\u539f\u5b50\u64cd\u4f5c：
\n \/\/ 1. \u68c0\u67e5 map \u4e2d\u662f\u5426\u5b58\u5728\u6307\u5b9a key（word）
\n \/\/ 2. \u5982\u679c\u4e0d\u5b58\u5728，\u5219\u6267\u884c (key) -> new LongAdder() \u521b\u5efa\u65b0\u7684 LongAdder \u4f5c\u4e3a value
\n \/\/ 3. \u5982\u679c\u5b58\u5728，\u5219\u76f4\u63a5\u83b7\u53d6\u5df2\u6709\u7684 LongAdder
\n \/\/ \u8be5\u64cd\u4f5c\u662f\u7ebf\u7a0b\u5b89\u5168\u7684，\u9002\u5408\u591a\u7ebf\u7a0b\u73af\u5883
\n LongAdder value = map.computeIfAbsent(word, (key) -> new LongAdder());<\/p>\n
\/\/ \u6267\u884c\u7d2f\u52a0\u64cd\u4f5c，LongAdder \u662f\u7ebf\u7a0b\u5b89\u5168\u7684\u7d2f\u52a0\u5668，\u6bd4 AtomicLong \u66f4\u9002\u5408\u9ad8\u5e76\u53d1\u573a\u666f
\n value.increment();<\/p>\n
\/\/ \u4ee5\u4e0b\u662f\u88ab\u6ce8\u91ca\u7684\u65e7\u5b9e\u73b0\u903b\u8f91，\u4fdd\u7559\u7528\u4e8e\u5bf9\u6bd4\u8bf4\u660e：
\n \/*
\n \/\/ \u65e7\u903b\u8f91：\u5148 get \u518d put，\u975e\u539f\u5b50\u64cd\u4f5c（\u591a\u7ebf\u7a0b\u4e0b\u53ef\u80fd\u6709\u95ee\u9898）
\n Integer counter = map.get(word);
\n int newValue = counter == null ? 1 : counter + 1;
\n map.put(word, newValue);
\n *\/
\n }
\n }
\n );
\n }<\/p>\n
computeIfAbsent\u4fdd\u8bc1\u4e09\u4e2a\u64cd\u4f5c\u7684\u539f\u5b50\u6027，LongAdder\u4fdd\u8bc1\u7d2f\u52a0\u64cd\u4f5c\u662f\u539f\u5b50\u7684<\/p>\n<\/p>\n
<\/p>\n
\u7a76\u5176\u539f\u56e0，\u662f\u56e0\u4e3a\u5728\u591a\u7ebf\u7a0b\u73af\u5883\u4e0b\u4f7f\u7528\u4e86\u975e\u7ebf\u7a0b\u5b89\u5168\u7684 map \u96c6\u5408<\/p>\n
JDK 8 \u867d\u7136\u5c06\u6269\u5bb9\u7b97\u6cd5\u505a\u4e86\u8c03\u6574，\u4e0d\u518d\u5c06\u5143\u7d20\u52a0\u5165\u94fe\u8868\u5934（\u800c\u662f\u4fdd\u6301\u4e0e\u6269\u5bb9\u524d\u4e00\u6837\u7684\u987a\u5e8f），\u4f46\u4ecd\u4e0d\u610f\u5473\u7740\u80fd \u591f\u5728\u591a\u7ebf\u7a0b\u73af\u5883\u4e0b\u80fd\u591f\u5b89\u5168\u6269\u5bb9，\u8fd8\u4f1a\u51fa\u73b0\u5176\u5b83\u95ee\u9898（\u5982\u6269\u5bb9\u4e22\u6570\u636e）<\/p>\n
\u53ef\u4ee5\u770b\u5230\u5b9e\u73b0\u4e86\u61d2\u60f0\u521d\u59cb\u5316，\u5728\u6784\u9020\u65b9\u6cd5\u4e2d\u4ec5\u4ec5\u8ba1\u7b97\u4e86 table \u7684\u5927\u5c0f，\u4ee5\u540e\u5728\u7b2c\u4e00\u6b21\u4f7f\u7528\u65f6\u624d\u4f1a\u771f\u6b63\u521b\u5efa<\/p>\n
\/\/ ConcurrentHashMap \u7684\u6784\u9020\u51fd\u6570，\u5141\u8bb8\u6307\u5b9a\u521d\u59cb\u5bb9\u91cf\u3001\u8d1f\u8f7d\u56e0\u5b50\u3001\u5e76\u53d1\u7ea7\u522b
\npublic ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
\n \/\/ 1. \u53c2\u6570\u5408\u6cd5\u6027\u6821\u9a8c
\n \/\/ \u8d1f\u8f7d\u56e0\u5b50\u5fc5\u987b > 0，\u521d\u59cb\u5bb9\u91cf\u4e0d\u80fd < 0，\u5e76\u53d1\u7ea7\u522b\u4e0d\u80fd <= 0
\n if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) {
\n throw new IllegalArgumentException();
\n }
\n \/\/ 2. \u8c03\u6574\u521d\u59cb\u5bb9\u91cf（\u4e0e\u5e76\u53d1\u7ea7\u522b\u5173\u8054）
\n \/\/ \u5982\u679c\u521d\u59cb\u5bb9\u91cf\u5c0f\u4e8e\u5e76\u53d1\u7ea7\u522b，\u5c06\u521d\u59cb\u5bb9\u91cf\u8c03\u6574\u4e3a\u5e76\u53d1\u7ea7\u522b
\n \/\/ \u539f\u56e0：ConcurrentHashMap \u5185\u90e8\u7528\u5206\u6bb5（\u6876）\u5b58\u50a8\u6570\u636e，\u81f3\u5c11\u8981\u4fdd\u8bc1\u6876\u6570\u91cf >= \u5e76\u53d1\u7ea7\u522b，
\n \/\/ \u907f\u514d\u54c8\u5e0c\u51b2\u7a81\u8fc7\u4e8e\u96c6\u4e2d，\u5f71\u54cd\u5e76\u53d1\u6027\u80fd
\n if (initialCapacity < concurrencyLevel) {
\n initialCapacity = concurrencyLevel;
\n }
\n \/\/ 3. \u8ba1\u7b97\u8868\u7684\u76ee\u6807\u5927\u5c0f（\u57fa\u4e8e\u521d\u59cb\u5bb9\u91cf\u548c\u8d1f\u8f7d\u56e0\u5b50）
\n \/\/ \u516c\u5f0f：size = 1.0 + (\u521d\u59cb\u5bb9\u91cf \/ \u8d1f\u8f7d\u56e0\u5b50)，\u5411\u4e0a\u53d6\u6574（\u8f6c\u4e3a long \u907f\u514d\u6ea2\u51fa）
\n \/\/ \u4f5c\u7528：\u6839\u636e\u521d\u59cb\u5bb9\u91cf\u548c\u8d1f\u8f7d\u56e0\u5b50，\u4f30\u7b97\u9700\u8981\u7684\u54c8\u5e0c\u8868\u5bb9\u91cf，\u4e3a\u540e\u7eed\u8c03\u6574\u4e3a 2 \u7684\u5e42\u505a\u51c6\u5907
\n long size = (long)(1.0 + (long)initialCapacity \/ loadFactor);
\n \/\/ 4. \u9650\u5236\u5bb9\u91cf\u6700\u5927\u503c
\n \/\/ MAXIMUM_CAPACITY \u662f ConcurrentHashMap \u5141\u8bb8\u7684\u6700\u5927\u5bb9\u91cf（\u901a\u5e38\u662f 1<<30 \u7b49，\u4e0d\u540c\u7248\u672c\u53ef\u80fd\u6709\u5dee\u5f02）
\n \/\/ \u5982\u679c\u8ba1\u7b97\u51fa\u7684 size \u8d85\u8fc7\u6700\u5927\u503c，\u5c31\u7528 MAXIMUM_CAPACITY，\u5426\u5219\u8c03\u6574\u4e3a\u6700\u63a5\u8fd1\u7684 2 \u7684\u5e42
\n int cap = (size >= (long)MAXIMUM_CAPACITY) ?
\n MAXIMUM_CAPACITY :
\n \/\/ tableSizeFor \u65b9\u6cd5\u4f1a\u8fd4\u56de\u5927\u4e8e\u7b49\u4e8e\u7ed9\u5b9a\u6570\u503c\u7684\u6700\u5c0f\u7684 2 \u7684\u5e42（\u5982\u8f93\u5165 5 \u8fd4\u56de 8，\u8f93\u5165 8 \u8fd4\u56de 8 ）
\n tableSizeFor((int)size);
\n \/\/ 5. \u521d\u59cb\u5316 sizeCtl \u5b57\u6bb5
\n \/\/ sizeCtl \u5728 ConcurrentHashMap \u4e2d\u662f\u4e00\u4e2a\u591a\u529f\u80fd\u7684\u63a7\u5236\u5b57\u6bb5：
\n \/\/ – \u521d\u59cb\u5316\u65f6，\u5b58\u50a8\u54c8\u5e0c\u8868\u7684\u5bb9\u91cf（\u540e\u7eed\u4f1a\u8c03\u6574\u4e3a\u5176\u4ed6\u72b6\u6001，\u5982 -1 \u8868\u793a\u6b63\u5728\u521d\u59cb\u5316 ）
\n \/\/ – \u6269\u5bb9\u65f6，\u7528\u4e8e\u534f\u8c03\u591a\u7ebf\u7a0b\u7684\u6269\u5bb9\u64cd\u4f5c\u7b49
\n this.sizeCtl = cap;
\n}<\/p>\n
\u5168\u7a0b\u4e0d\u52a0\u9501<\/p>\n
public V get(Object key) {
\n Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
\n \/\/ 1. \u8ba1\u7b97 key \u7684\u54c8\u5e0c\u503c：
\n \/\/ – \u5148\u8c03\u7528 key.hashCode() \u83b7\u53d6\u539f\u59cb\u54c8\u5e0c
\n \/\/ – spread \u65b9\u6cd5\u901a\u8fc7\u5f02\u6216\u548c\u4f4d\u8fd0\u7b97，\u786e\u4fdd\u7ed3\u679c\u4e3a\u6b63\u6570（\u907f\u514d\u54c8\u5e0c\u51b2\u7a81）
\n int h = spread(key.hashCode());<\/p>\n
\/\/ 2. \u68c0\u67e5\u54c8\u5e0c\u8868\u72b6\u6001：
\n \/\/ – tab = table：\u83b7\u53d6\u5f53\u524d\u54c8\u5e0c\u8868\u6570\u7ec4
\n \/\/ – n = tab.length > 0：\u54c8\u5e0c\u8868\u5df2\u521d\u59cb\u5316\u4e14\u957f\u5ea6\u6709\u6548
\n \/\/ – e = tabAt(…)：\u901a\u8fc7 tabAt \u65b9\u6cd5（\u7ebf\u7a0b\u5b89\u5168）\u83b7\u53d6\u6876\u4f4d\u7f6e\u7684\u5934\u8282\u70b9
\n if ((tab = table) != null && (n = tab.length) > 0 &&
\n (e = tabAt(tab, (n – 1) & h)) != null) {<\/p>\n
\/\/ 3. \u68c0\u67e5\u5934\u8282\u70b9\u662f\u5426\u5339\u914d\u76ee\u6807 key：
\n \/\/ – eh = e.hash：\u83b7\u53d6\u5934\u8282\u70b9\u7684\u54c8\u5e0c\u503c
\n \/\/ – \u5148\u5bf9\u6bd4\u54c8\u5e0c\u503c（\u5feb\u901f\u7b5b\u9009），\u518d\u5bf9\u6bd4 key \u5bf9\u8c61（== \u6216 equals）
\n if ((eh = e.hash) == h) {
\n if (((ek = e.key) == key) || (ek != null && key.equals(ek)))
\n return e.val; \/\/ \u627e\u5230\u5339\u914d，\u8fd4\u56de\u503c
\n }<\/p>\n
\/\/ 4. \u5904\u7406\u7279\u6b8a\u8282\u70b9（\u54c8\u5e0c\u503c\u4e3a\u8d1f\u6570\u7684\u60c5\u51b5）：
\n \/\/ – eh < 0 \u8868\u793a\u8282\u70b9\u662f ForwardingNode（\u6269\u5bb9\u4e2d）\u6216 TreeBin（\u7ea2\u9ed1\u6811）
\n \/\/ – \u8c03\u7528 find \u65b9\u6cd5\u9012\u5f52\u67e5\u627e（\u6269\u5bb9\u65f6\u904d\u5386\u65b0\u3001\u65e7\u8868；\u7ea2\u9ed1\u6811\u65f6\u6309\u6811\u7ed3\u6784\u67e5\u627e）
\n else if (eh < 0)
\n return (p = e.find(h, key)) != null ? p.val : null;<\/p>\n
\/\/ 5. \u904d\u5386\u94fe\u8868\u67e5\u627e\u5339\u914d\u7684 key：
\n \/\/ – \u54c8\u5e0c\u503c\u5339\u914d\u65f6，\u518d\u5bf9\u6bd4 key \u5bf9\u8c61（== \u6216 equals）
\n while ((e = e.next) != null) {
\n if (e.hash == h &&
\n ((ek = e.key) == key || (ek != null && key.equals(ek))))
\n return e.val; \/\/ \u627e\u5230\u5339\u914d，\u8fd4\u56de\u503c
\n }
\n }
\n \/\/ 6. \u672a\u627e\u5230 key，\u8fd4\u56de null
\n return null;
\n}<\/p>\n
\u8ba1\u7b97\u54c8\u5e0c：
\n\u901a\u8fc7\u00a0spread\u00a0\u65b9\u6cd5\u8ba1\u7b97\u00a0key\u00a0\u7684\u54c8\u5e0c\u503c，\u786e\u4fdd\u7ed3\u679c\u4e3a\u6b63\u6570，\u907f\u514d\u54c8\u5e0c\u51b2\u7a81\u3002<\/p>\n<\/li>\n
\u68c0\u67e5\u54c8\u5e0c\u8868\u72b6\u6001：
\n\u9a8c\u8bc1\u54c8\u5e0c\u8868\u662f\u5426\u521d\u59cb\u5316\u3001\u957f\u5ea6\u662f\u5426\u6709\u6548，\u5e76\u7528\u00a0tabAt\u00a0\u7ebf\u7a0b\u5b89\u5168\u5730\u83b7\u53d6\u6876\u4f4d\u7f6e\u7684\u5934\u8282\u70b9\u3002<\/p>\n<\/li>\n
\u5339\u914d\u5934\u8282\u70b9：
\n\u5148\u5bf9\u6bd4\u5934\u8282\u70b9\u7684\u54c8\u5e0c\u503c，\u518d\u7528\u00a0==\u00a0\u6216\u00a0equals\u00a0\u5bf9\u6bd4\u00a0key，\u5339\u914d\u5219\u76f4\u63a5\u8fd4\u56de\u503c\u3002<\/p>\n<\/li>\n
\u5904\u7406\u7279\u6b8a\u8282\u70b9：
\n\u82e5\u5934\u8282\u70b9\u54c8\u5e0c\u4e3a\u8d1f\u6570（\u6269\u5bb9\u4e2d\u6216\u7ea2\u9ed1\u6811），\u8c03\u7528\u00a0find\u00a0\u65b9\u6cd5\u9012\u5f52\u67e5\u627e\u76ee\u6807\u00a0key\u3002<\/p>\n<\/li>\n
\u904d\u5386\u94fe\u8868\u67e5\u627e：
\n\u54c8\u5e0c\u503c\u5339\u914d\u65f6，\u9010\u4e00\u904d\u5386\u94fe\u8868\u8282\u70b9，\u7528\u00a0==\u00a0\u6216\u00a0equals\u00a0\u5bf9\u6bd4\u00a0key，\u627e\u5230\u5219\u8fd4\u56de\u503c\u3002<\/p>\n<\/li>\n
\u672a\u627e\u5230\u8fd4\u56de\u00a0null：
\n\u82e5\u904d\u5386\u5b8c\u6240\u6709\u8282\u70b9\u4ecd\u672a\u5339\u914d，\u8fd4\u56de\u00a0null\u3002<\/p>\n<\/li>\n
\u4ee5\u4e0b\u6570\u7ec4\u7b80\u79f0（table）,\u94fe\u8868\u7b80\u79f0（bin）<\/p>\n
public V put(K key, V value) {
\n return putVal(key, value, false);
\n}<\/p>\n
final V putVal(K key, V value, boolean onlyIfAbsent) {
\n \/\/ 1. \u6821\u9a8c key \u548c value \u4e0d\u4e3a null
\n if (key == null || value == null) throw new NullPointerException();<\/p>\n
\/\/ 2. \u8ba1\u7b97 key \u7684\u54c8\u5e0c\u503c
\n int hash = spread(key.hashCode());
\n int binCount = 0; \/\/ \u8bb0\u5f55\u94fe\u8868\u957f\u5ea6（\u7528\u4e8e\u5224\u65ad\u662f\u5426\u9700\u8981\u6811\u5316）<\/p>\n
\/\/ 3. \u65e0\u9650\u5faa\u73af，\u786e\u4fdd\u64cd\u4f5c\u5b8c\u6210
\n for (Node<K, V>[] tab = table; ; ) {
\n Node<K, V> f; \/\/ \u5f53\u524d\u6876\u7684\u5934\u8282\u70b9
\n int n, i, fh; \/\/ n: \u54c8\u5e0c\u8868\u957f\u5ea6; i: \u6876\u7684\u4e0b\u6807; fh: \u5934\u8282\u70b9\u7684\u54c8\u5e0c\u503c<\/p>\n
\/\/ 3.1 \u521d\u59cb\u5316\u54c8\u5e0c\u8868（\u5ef6\u8fdf\u521d\u59cb\u5316）
\n if (tab == null || (n = tab.length) == 0) {
\n tab = initTable(); \/\/ \u4f7f\u7528 CAS \u521d\u59cb\u5316，\u65e0\u9700 synchronized
\n }<\/p>\n
\/\/ 3.2 \u5b9a\u4f4d\u6876\u7684\u4f4d\u7f6e，\u5e76\u68c0\u67e5\u6876\u662f\u5426\u4e3a\u7a7a
\n else if ((f = tabAt(tab, i = (n – 1) & hash)) == null) {
\n \/\/ \u6876\u4e3a\u7a7a，\u4f7f\u7528 CAS \u63d2\u5165\u65b0\u8282\u70b9
\n if (casTabAt(tab, i, null, new Node<>(hash, key, value, null))) {
\n break; \/\/ \u63d2\u5165\u6210\u529f，\u9000\u51fa\u5faa\u73af
\n }
\n }<\/p>\n
\/\/ 3.3 \u5904\u7406\u6269\u5bb9\u4e2d\u7684 ForwardingNode（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u9700\u8981\u5904\u7406\u6269\u5bb9\u903b\u8f91）
\n else if ((fh = f.hash) == -1) {
\n \/\/ \u5e2e\u52a9\u6269\u5bb9（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u9700\u8981\u8fc1\u79fb\u6570\u636e）
\n tab = table; \/\/ \u91cd\u65b0\u83b7\u53d6\u6700\u65b0\u7684\u54c8\u5e0c\u8868
\n }<\/p>\n
\/\/ 3.4 \u5904\u7406\u975e\u7a7a\u6876（\u94fe\u8868\u6216\u7ea2\u9ed1\u6811）
\n else {
\n V oldVal = null;
\n \/\/ \u52a0\u9501（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u4f7f\u7528 synchronized \u6216 CAS \u9501）
\n synchronized (f) {
\n if (tabAt(tab, i) == f) { \/\/ \u518d\u6b21\u68c0\u67e5\u5934\u8282\u70b9\u662f\u5426\u53d8\u5316
\n if (fh >= 0) { \/\/ \u5934\u8282\u70b9\u662f\u666e\u901a\u8282\u70b9（\u94fe\u8868）
\n binCount = 1;
\n \/\/ \u904d\u5386\u94fe\u8868
\n for (Node<K, V> e = f; ; ++binCount) {
\n K ek;
\n \/\/ 3.4.1 \u627e\u5230\u76f8\u540c key \u7684\u8282\u70b9
\n if (e.hash == hash &&
\n ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
\n oldVal = e.val;
\n if (!onlyIfAbsent) {
\n e.val = value; \/\/ \u66f4\u65b0\u503c
\n }
\n break;
\n }
\n Node<K, V> pred = e;
\n \/\/ 3.4.2 \u904d\u5386\u5230\u94fe\u8868\u672b\u5c3e，\u63d2\u5165\u65b0\u8282\u70b9
\n if ((e = e.next) == null) {
\n pred.next = new Node<>(hash, key, value, null);
\n break;
\n }
\n }
\n }
\n \/\/ 3.5 \u5904\u7406\u7ea2\u9ed1\u6811（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u9700\u8981\u6811\u5316\u903b\u8f91）
\n else {
\n \/\/ … \u6811\u5316\u903b\u8f91（\u7701\u7565） …
\n }
\n }
\n }<\/p>\n
\/\/ 3.6 \u5224\u65ad\u662f\u5426\u9700\u8981\u6811\u5316（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u9700\u8981\u5224\u65ad\u94fe\u8868\u957f\u5ea6）
\n if (binCount != 0) {
\n if (binCount >= 8) {
\n \/\/ \u94fe\u8868\u8f6c\u7ea2\u9ed1\u6811（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u9700\u8981\u6811\u5316\u64cd\u4f5c）
\n }
\n if (oldVal != null) {
\n return oldVal; \/\/ \u8fd4\u56de\u65e7\u503c
\n }
\n break;
\n }
\n }
\n }<\/p>\n
\/\/ 4. \u66f4\u65b0 size（\u7b80\u5316\u7248，\u5b9e\u9645 JDK \u4e2d\u9700\u8981 CAS \u66f4\u65b0）
\n \/\/ … \u7701\u7565\u66f4\u65b0 size \u7684\u903b\u8f91 …<\/p>\n
return null; \/\/ \u8fd4\u56de\u65e7\u503c（\u5982\u679c\u6ca1\u6709\u65e7\u503c\u5219\u8fd4\u56de null）
\n}<\/p>\n
\u6821\u9a8c\u53c2\u6570：
\n\u68c0\u67e5\u00a0key\u00a0\u548c\u00a0value\u00a0\u662f\u5426\u4e3a\u00a0null，\u82e5\u4e3a\u00a0null\u00a0\u5219\u629b\u51fa\u00a0NullPointerException\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97\u54c8\u5e0c：
\n\u901a\u8fc7\u00a0spread\u00a0\u65b9\u6cd5\u8ba1\u7b97\u00a0key\u00a0\u7684\u54c8\u5e0c\u503c，\u786e\u4fdd\u54c8\u5e0c\u5206\u5e03\u5747\u5300\u3002<\/p>\n<\/li>\n
\u521d\u59cb\u5316\u54c8\u5e0c\u8868：
\n\u5982\u679c\u54c8\u5e0c\u8868\u672a\u521d\u59cb\u5316（tab == null\u00a0\u6216\u957f\u5ea6\u4e3a 0），\u5219\u901a\u8fc7\u00a0initTable\u00a0\u5ef6\u8fdf\u521d\u59cb\u5316\u3002<\/p>\n<\/li>\n
\u5b9a\u4f4d\u6876\u5e76\u63d2\u5165\u8282\u70b9：<\/p>\n
\u5904\u7406\u6269\u5bb9：
\n\u5982\u679c\u9047\u5230\u6269\u5bb9\u4e2d\u7684\u00a0ForwardingNode，\u534f\u52a9\u5b8c\u6210\u6269\u5bb9（\u7b80\u5316\u7248，\u5b9e\u9645\u903b\u8f91\u66f4\u590d\u6742 ）\u3002<\/p>\n<\/li>\n
\u94fe\u8868\u6811\u5316：
\n\u5982\u679c\u94fe\u8868\u957f\u5ea6\u8d85\u8fc7\u9608\u503c（\u9ed8\u8ba4 8），\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811，\u63d0\u5347\u67e5\u8be2\u6548\u7387\u3002（\u4ec5\u4ec5\u53ea\u9501\u4f4f\u6876）<\/p>\n<\/li>\n
\u66f4\u65b0 size：
\n\u4f7f\u7528\u00a0CAS\u00a0\u66f4\u65b0\u54c8\u5e0c\u8868\u7684\u5927\u5c0f（\u7b80\u5316\u7248，\u5b9e\u9645\u903b\u8f91\u66f4\u590d\u6742 ）\u3002<\/p>\n<\/li>\n
\u8fd4\u56de\u65e7\u503c：
\n\u5982\u679c\u63d2\u5165\u524d\u5b58\u5728\u65e7\u503c，\u5219\u8fd4\u56de\u65e7\u503c；\u5426\u5219\u8fd4\u56de\u00a0null\u3002<\/p>\n<\/li>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/08\/20250814061548-689d7f1426579.png\")
<\/p>\n
\u5982\u679c\u9047\u5230\u6269\u5bb9\u4e2d\u7684\u00a0ForwardingNode，\u534f\u52a9\u5b8c\u6210\u6269\u5bb9(\u9501\u4f4f\u94fe\u8868\u5e2e\u5fd9\u6269\u5bb9)<\/p>\n
\u4fdd\u8bc1\u53ea\u6709\u4e00\u4e2a\u7ebf\u7a0b\u80fd\u521b\u5efahash\u8868，\u5176\u4ed6\u7ebf\u7a0b\u90fd\u662f\u76f2\u7b49\u5f85<\/p>\n
private final Node<K, V>[] initTable() {
\n Node<K, V>[] tab;
\n int sc;
\n \/\/ \u5faa\u73af\u5c1d\u8bd5\u521d\u59cb\u5316：\u53ea\u8981 table \u672a\u521d\u59cb\u5316（null \u6216\u957f\u5ea6 0 ），\u5c31\u6301\u7eed\u5c1d\u8bd5
\n while ((tab = table) == null || tab.length == 0) {
\n \/\/ sizeCtl < 0 \u8bf4\u660e\u6709\u5176\u4ed6\u7ebf\u7a0b\u6b63\u5728\u521d\u59cb\u5316，\u5f53\u524d\u7ebf\u7a0b\u4e3b\u52a8\u8ba9\u51fa CPU，\u907f\u514d\u7ade\u4e89
\n if ((sc = sizeCtl) < 0) {
\n Thread.yield();
\n }
\n \/\/ \u5c1d\u8bd5\u7528 CAS \u5c06 sizeCtl \u4ece sc（\u539f\u72b6\u6001）\u6539\u4e3a -1，\u6807\u8bb0\u201c\u6b63\u5728\u521d\u59cb\u5316\u201d
\n else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
\n try {
\n \/\/ \u4e8c\u6b21\u68c0\u67e5：\u9632\u6b62\u5176\u4ed6\u7ebf\u7a0b\u5df2\u7ecf\u521d\u59cb\u5316\u4e86 table
\n if ((tab = table) == null || tab.length == 0) {
\n \/\/ \u786e\u5b9a\u521d\u59cb\u5316\u5bb9\u91cf：\u6709\u81ea\u5b9a\u4e49\u5bb9\u91cf（sc > 0 ）\u5219\u7528，\u5426\u5219\u7528\u9ed8\u8ba4 16
\n int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
\n \/\/ \u521b\u5efa Node \u6570\u7ec4，\u957f\u5ea6\u4e3a n，\u4f5c\u4e3a\u54c8\u5e0c\u8868\u7684\u5b58\u50a8\u7ed3\u6784
\n Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
\n \/\/ \u5c06\u65b0\u6570\u7ec4\u8d4b\u503c\u7ed9 table，\u5b8c\u6210\u521d\u59cb\u5316
\n table = tab = nt;
\n \/\/ \u8ba1\u7b97\u6269\u5bb9\u9608\u503c：n – (n >>> 2) \u7b49\u4ef7\u4e8e n * 0.75（\u8d1f\u8f7d\u56e0\u5b50 0.75 ）
\n sc = n – (n >>> 2);
\n }
\n } finally {
\n \/\/ \u66f4\u65b0 sizeCtl \u4e3a\u6269\u5bb9\u9608\u503c，\u540e\u7eed\u7528\u4e8e\u5224\u65ad\u662f\u5426\u9700\u8981\u6269\u5bb9
\n sizeCtl = sc;
\n }
\n break; \/\/ \u521d\u59cb\u5316\u5b8c\u6210，\u8df3\u51fa\u5faa\u73af
\n }
\n }
\n return tab; \/\/ \u8fd4\u56de\u521d\u59cb\u5316\u597d\u7684\u54c8\u5e0c\u8868\u6570\u7ec4
\n}<\/p>\n
\u5229\u7528\u4e86Longadder\u7684\u601d\u60f3，\u8bbe\u7f6e\u4e86\u591a\u4e2a\u7d2f\u52a0\u5355\u5143，\u51cf\u5c11CAS\u64cd\u4f5c\u7684\u51b2\u7a81<\/p>\n
private final void addCount(long x, int check) {
\n CounterCell[] as; long b, s;
\n \/\/ \u5206\u652f 1：\u4f18\u5148\u4f7f\u7528 CounterCells \u6216 CAS \u66f4\u65b0 baseCount
\n if ((as = counterCells) != null ||
\n \/\/ \u82e5 counterCells \u4e0d\u5b58\u5728，\u5c1d\u8bd5 CAS \u66f4\u65b0 baseCount（\u57fa\u7840\u8ba1\u6570 ）
\n !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
\n CounterCell a; long v; int m;
\n boolean uncontended = true; \/\/ \u6807\u8bb0 Cell \u7684 CAS \u662f\u5426\u6210\u529f
\n \/\/ \u5206\u652f 2：\u5904\u7406 CounterCells \u7684\u7ade\u4e89
\n if (as == null || (m = as.length – 1) < 0 ||
\n \/\/ \u8ba1\u7b97\u7ebf\u7a0b\u5bf9\u5e94\u7684 Cell \u4e0b\u6807（\u7ebf\u7a0b\u672c\u5730\u968f\u673a\u6570 & \u957f\u5ea6 -1 ）
\n (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
\n \/\/ \u5c1d\u8bd5 CAS \u7d2f\u52a0 Cell \u7684\u503c
\n !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
\n \/\/ \u7ade\u4e89\u5931\u8d25，\u8fdb\u5165\u5168\u91cf\u7d2f\u52a0\u903b\u8f91（\u521b\u5efa Cell \u6216\u6269\u5bb9 CounterCells ）
\n fullAddCount(x, uncontended);
\n return;
\n }
\n \/\/ \u5206\u652f 3：\u68c0\u67e5\u662f\u5426\u9700\u8981\u89e6\u53d1\u6269\u5bb9（check \u53c2\u6570\u63a7\u5236 ）
\n if (check <= 1)
\n return;
\n \/\/ \u8ba1\u7b97\u603b\u8ba1\u6570（baseCount + \u6240\u6709 Cell \u7684\u503c ）
\n s = sumCount();
\n }
\n \/\/ \u5206\u652f 4：\u6839\u636e\u603b\u8ba1\u6570\u68c0\u67e5\u662f\u5426\u9700\u8981\u6269\u5bb9\u54c8\u5e0c\u8868
\n if (check >= 0) {
\n Node<K,V>[] tab, nt; int n, sc;
\n while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
\n (n = tab.length) < MAXIMUM_CAPACITY) {
\n int rs = resizeStamp(n);
\n if (sc < 0) { \/\/ \u54c8\u5e0c\u8868\u6b63\u5728\u6269\u5bb9
\n \/\/ \u68c0\u67e5\u6269\u5bb9\u72b6\u6001，\u907f\u514d\u91cd\u590d\u6269\u5bb9
\n if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
\n sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
\n transferIndex <= 0)
\n break;
\n \/\/ \u534f\u52a9\u6269\u5bb9
\n if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
\n transfer(tab, nt);
\n }
\n else { \/\/ \u54c8\u5e0c\u8868\u672a\u5728\u6269\u5bb9，\u5c1d\u8bd5\u89e6\u53d1\u6269\u5bb9
\n if (U.compareAndSwapInt(this, SIZECTL, sc,
\n (rs << RESIZE_STAMP_SHIFT) + 2))
\n transfer(tab, null);
\n }
\n s = sumCount(); \/\/ \u91cd\u65b0\u8ba1\u7b97\u603b\u8ba1\u6570，\u5224\u65ad\u662f\u5426\u4ecd\u9700\u6269\u5bb9
\n }
\n }
\n}<\/p>\n
\u4f18\u5148\u7d2f\u52a0\u5c1d\u8bd5：
\n\u82e5\u00a0CounterCells\u00a0\u5b58\u5728\u5219\u7528\u5176\u7d2f\u52a0，\u5426\u5219\u5c1d\u8bd5\u00a0CAS\u00a0\u66f4\u65b0\u00a0baseCount，\u907f\u514d\u9501\u7ade\u4e89\u3002<\/p>\n<\/li>\n
\u5904\u7406 Cell \u7ade\u4e89：
\n\u8ba1\u7b97\u7ebf\u7a0b\u5bf9\u5e94\u7684\u00a0Cell\u00a0\u4e0b\u6807，\u5c1d\u8bd5\u00a0CAS\u00a0\u7d2f\u52a0\u00a0Cell\u00a0\u7684\u503c；\u82e5\u5931\u8d25\u5219\u8fdb\u5165\u00a0fullAddCount\u00a0\u5904\u7406\u3002<\/p>\n<\/li>\n
\u5168\u91cf\u7d2f\u52a0\u903b\u8f91：
\n\u7ade\u4e89\u5931\u8d25\u65f6，\u521b\u5efa\u65b0\u00a0Cell\u00a0\u6216\u6269\u5bb9\u00a0CounterCells，\u4fdd\u8bc1\u8ba1\u6570\u4e0d\u4e22\u5931\u3002<\/p>\n<\/li>\n
\u68c0\u67e5\u6269\u5bb9\u6761\u4ef6：
\n\u6839\u636e\u00a0check\u00a0\u53c2\u6570\u5224\u65ad\u662f\u5426\u9700\u8981\u89e6\u53d1\u54c8\u5e0c\u8868\u6269\u5bb9，\u901a\u8fc7\u00a0sumCount\u00a0\u8ba1\u7b97\u603b\u8ba1\u6570\u3002<\/p>\n<\/li>\n
\u89e6\u53d1\u54c8\u5e0c\u8868\u6269\u5bb9：
\n\u82e5\u603b\u8ba1\u6570\u8d85\u8fc7\u9608\u503c，\u901a\u8fc7\u00a0transfer\u00a0\u65b9\u6cd5\u6269\u5bb9\u54c8\u5e0c\u8868，\u591a\u7ebf\u7a0b\u534f\u4f5c\u8fc1\u79fb\u6570\u636e\u3002<\/p>\n<\/li>\n
\u501f\u9274\u00a0LongAdder\u00a0\u7684\u8bbe\u8ba1\u601d\u8def，\u5c06\u8ba1\u6570\u5206\u4e3a\u00a0baseCount（\u65e0\u7ade\u4e89 ）\u548c\u00a0counterCells（\u6709\u7ade\u4e89 ），size\u00a0\u8ba1\u7b97\u65f6\u518d\u7d2f\u52a0，\u907f\u514d\u5b9e\u65f6\u7ef4\u62a4\u7cbe\u786e\u8ba1\u6570\u5e26\u6765\u7684\u9ad8\u5e76\u53d1\u7ade\u4e89\u3002<\/p>\n
\u9ad8\u5e76\u53d1\u4e0b，baseCount\u00a0\u548c\u00a0counterCells\u00a0\u7684\u66f4\u65b0\u53ef\u80fd\u5b58\u5728\u5ef6\u8fdf，size\u00a0\u65b9\u6cd5\u8fd4\u56de\u7684\u662f \u201c\u8fd1\u4f3c\u51c6\u786e\u201d \u7684\u8ba1\u6570（\u6700\u7ec8\u4f1a\u4e00\u81f4，\u4f46\u83b7\u53d6\u77ac\u95f4\u53ef\u80fd\u6709\u504f\u5dee ），\u8fd9\u662f\u4e3a\u4e86\u6362\u53d6\u9ad8\u5e76\u53d1\u573a\u666f\u4e0b\u7684\u6027\u80fd\u63d0\u5347\u3002<\/p>\n
\/\/ size \u65b9\u6cd5，\u7528\u4e8e\u83b7\u53d6 ConcurrentHashMap \u4e2d\u5143\u7d20\u7684\u6570\u91cf
\npublic int size() {
\n \/\/ \u8c03\u7528 sumCount \u65b9\u6cd5，\u8ba1\u7b97 baseCount \u548c\u6240\u6709 counterCells \u4e2d\u7684\u8ba1\u6570\u503c\u603b\u548c
\n long n = sumCount();
\n \/\/ \u5904\u7406\u8ba1\u6570\u503c\u7684\u8fb9\u754c\u60c5\u51b5：
\n \/\/ – \u5982\u679c\u603b\u548c n \u5c0f\u4e8e 0，\u8fd4\u56de 0（\u7406\u8bba\u4e0a\u4e0d\u4f1a\u51fa\u73b0，\u8fd9\u91cc\u505a\u9632\u5fa1\u6027\u5904\u7406 ）
\n \/\/ – \u5982\u679c\u603b\u548c n \u8d85\u8fc7 Integer \u7684\u6700\u5927\u503c，\u8fd4\u56de Integer.MAX_VALUE
\n \/\/ – \u5426\u5219，\u5c06 long \u7c7b\u578b\u7684\u603b\u548c\u8f6c\u6362\u4e3a int \u7c7b\u578b\u8fd4\u56de
\n return (n < 0L) ? 0 :
\n (n > (long) Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) n;
\n}<\/p>\n
\/\/ sumCount \u65b9\u6cd5，\u8ba1\u7b97 ConcurrentHashMap \u7684\u603b\u8ba1\u6570
\nfinal long sumCount() {
\n \/\/ \u83b7\u53d6\u5f53\u524d\u7684\u5206\u6bb5\u8ba1\u6570\u6570\u7ec4 counterCells
\n CounterCell[] as = counterCells;
\n CounterCell a;
\n \/\/ \u5148\u5c06\u57fa\u7840\u8ba1\u6570 baseCount \u7684\u503c\u7d2f\u52a0\u5230\u603b\u548c\u4e2d，baseCount \u7528\u4e8e\u65e0\u7ade\u4e89\u573a\u666f\u7684\u8ba1\u6570
\n long sum = baseCount.get();
\n \/\/ \u5982\u679c\u5206\u6bb5\u8ba1\u6570\u6570\u7ec4\u4e0d\u4e3a null，\u8bf4\u660e\u5b58\u5728\u7ade\u4e89\u573a\u666f，\u9700\u8981\u904d\u5386\u7d2f\u52a0\u6bcf\u4e2a Cell \u7684\u8ba1\u6570\u503c
\n if (as != null) {
\n for (int i = 0; i < as.length; ++i) {
\n \/\/ \u53d6\u51fa\u5f53\u524d Cell，\u82e5 Cell \u4e0d\u4e3a null，\u5c06\u5176\u8ba1\u6570\u503c\u7d2f\u52a0\u5230\u603b\u548c
\n if ((a = as[i]) != null) {
\n sum += a.value;
\n }
\n }
\n }
\n \/\/ \u8fd4\u56de\u7d2f\u52a0\u540e\u7684\u603b\u8ba1\u6570，\u4ee3\u8868 ConcurrentHashMap \u4e2d\u5143\u7d20\u7684\u5927\u81f4\u6570\u91cf（\u9ad8\u5e76\u53d1\u4e0b\u53ef\u80fd\u6709\u5ef6\u8fdf ）
\n return sum;
\n}<\/p>\n
\u591a\u7ebf\u7a0b\u534f\u4f5c\u6269\u5bb9：
\n\u901a\u8fc7\u00a0transferIndex\u00a0\u5206\u914d\u8fc1\u79fb\u8303\u56f4，\u5141\u8bb8\u591a\u7ebf\u7a0b\u540c\u65f6\u8fc1\u79fb\u4e0d\u540c\u6876，\u63d0\u5347\u6269\u5bb9\u6548\u7387\u3002<\/p>\n<\/li>\n
\u6e10\u8fdb\u5f0f\u8fc1\u79fb：
\n\u6bcf\u6b21\u8fc1\u79fb\u4e00\u4e2a\u6876，\u907f\u514d\u957f\u65f6\u95f4\u6301\u6709\u9501，\u4fdd\u8bc1\u9ad8\u5e76\u53d1\u4e0b\u7684\u54cd\u5e94\u6027\u3002<\/p>\n<\/li>\n
\u81ea\u52a8\u91cd\u5b9a\u5411：
\nForwardingNode\u00a0\u81ea\u52a8\u91cd\u5b9a\u5411\u8bbf\u95ee\u5230\u65b0\u6570\u7ec4，\u4fdd\u8bc1\u6269\u5bb9\u65f6\u8bfb\u5199\u64cd\u4f5c\u7684\u6b63\u786e\u6027\u3002<\/p>\n<\/li>\n
\u94fe\u8868\u4e0e\u7ea2\u9ed1\u6811\u62c6\u5206：
\n\u9002\u914d\u4e0d\u540c\u8282\u70b9\u7c7b\u578b（\u94fe\u8868 \/ \u7ea2\u9ed1\u6811 ），\u4fdd\u8bc1\u62c6\u5206\u548c\u8fc1\u79fb\u7684\u6548\u7387\u3002<\/p>\n<\/li>\n
\/\/ \u6807\u8bb0\u8282\u70b9\u6b63\u5728\u8fc1\u79fb（hash \u503c）
\nprivate static final int MOVED = -1;
\n\/\/ CPU \u6838\u5fc3\u6570
\nprivate static final int NCPU = Runtime.getRuntime().availableProcessors();
\n\/\/ \u6700\u5c0f\u8fc1\u79fb\u6b65\u957f
\nprivate static final int MIN_TRANSFER_STRIDE = 16; <\/p>\n
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
\n int n = tab.length, stride;
\n \/\/ \u8ba1\u7b97\u6bcf\u4e2a\u7ebf\u7a0b\u7684\u8fc1\u79fb\u6b65\u957f（stride）
\n if ((stride = (NCPU > 1) ? (n >>> 3) \/ NCPU : n) < MIN_TRANSFER_STRIDE)
\n stride = MIN_TRANSFER_STRIDE; \/\/ \u4fdd\u8bc1\u6b65\u957f\u4e0d\u5c0f\u4e8e 16
\n \/\/ \u521d\u59cb\u5316 nextTab（\u6269\u5bb9\u540e\u7684\u65b0\u6570\u7ec4）
\n if (nextTab == null) {
\n try {
\n nextTab = (Node<K,V>[])new Node<?,?>[n << 1]; \/\/ \u65b0\u5bb9\u91cf\u4e3a\u539f\u5bb9\u91cf\u7684 2 \u500d
\n } catch (Throwable ex) {
\n sizeCtl = Integer.MAX_VALUE;
\n return;
\n }
\n nextTable = nextTab; \/\/ \u8bb0\u5f55\u65b0\u6570\u7ec4
\n transferIndex = n; \/\/ \u521d\u59cb\u5316\u8fc1\u79fb\u7d22\u5f15
\n }
\n int nextn = nextTab.length;
\n \/\/ \u521b\u5efa ForwardingNode，\u6807\u8bb0\u5f53\u524d\u6876\u6b63\u5728\u8fc1\u79fb
\n ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
\n boolean advance = true; \/\/ \u6807\u8bb0\u662f\u5426\u7ee7\u7eed\u8fc1\u79fb\u4e0b\u4e00\u4e2a\u6876
\n boolean finishing = false; \/\/ \u6807\u8bb0\u662f\u5426\u5b8c\u6210\u6240\u6709\u8fc1\u79fb
\n \/\/ \u5faa\u73af\u8fc1\u79fb\u6bcf\u4e2a\u6876
\n for (int i = 0, bound = 0;;) {
\n Node<K,V> f; int fh;
\n \/\/ \u786e\u5b9a\u5f53\u524d\u7ebf\u7a0b\u7684\u8fc1\u79fb\u8303\u56f4
\n while (advance) {
\n int nextIndex, nextBound;
\n if (–transferIndex >= 0) {
\n nextIndex = transferIndex;
\n nextBound = (nextIndex > stride ? nextIndex – stride : 0);
\n bound = nextBound;
\n i = nextIndex;
\n advance = false;
\n } else {
\n advance = false;
\n if (finishing) { \/\/ \u6240\u6709\u6876\u8fc1\u79fb\u5b8c\u6210
\n nextTable = null;
\n table = nextTab; \/\/ \u66ff\u6362\u4e3a\u65b0\u6570\u7ec4
\n sizeCtl = (n << 1) – (n >>> 1); \/\/ \u66f4\u65b0\u6269\u5bb9\u9608\u503c
\n return;
\n }
\n }
\n }
\n \/\/ \u68c0\u67e5\u5f53\u524d\u6876\u662f\u5426\u8d8a\u754c
\n if (i < 0 || i >= n || i + n >= nextn)
\n continue;
\n \/\/ \u83b7\u53d6\u5f53\u524d\u6876\u7684\u5934\u8282\u70b9
\n if ((f = tabAt(tab, i)) == null) {
\n advance = casTabAt(tab, i, null, fwd); \/\/ \u6807\u8bb0\u6876\u4e3a\u8fc1\u79fb\u4e2d
\n }
\n \/\/ \u5904\u7406\u6b63\u5728\u8fc1\u79fb\u7684\u6876（\u8df3\u8fc7）
\n else if ((fh = f.hash) == MOVED) {
\n advance = true;
\n }
\n \/\/ \u8fc1\u79fb\u5f53\u524d\u6876\u7684\u8282\u70b9
\n else {
\n synchronized (f) { \/\/ \u52a0\u9501\u5f53\u524d\u6876\u7684\u5934\u8282\u70b9
\n if (tabAt(tab, i) == f) { \/\/ \u4e8c\u6b21\u68c0\u67e5，\u9632\u6b62\u5e76\u53d1\u4fee\u6539
\n Node<K,V> ln, hn;
\n if (fh >= 0) { \/\/ \u5934\u8282\u70b9\u662f\u666e\u901a\u94fe\u8868\u8282\u70b9
\n int runBit = fh & n; \/\/ \u8ba1\u7b97\u8fc1\u79fb\u540e\u7684\u4f4d\u7f6e
\n Node<K,V> lastRun = f;
\n Node<K,V> p = f.next;
\n \/\/ \u627e\u5230\u6700\u540e\u4e00\u6bb5\u8fde\u7eed\u76f8\u540c runBit \u7684\u8282\u70b9
\n while (p != null) {
\n int b = p.hash & n;
\n if (b != runBit) {
\n runBit = b;
\n lastRun = p;
\n }
\n p = p.next;
\n }
\n \/\/ \u5c06\u6700\u540e\u4e00\u6bb5\u8282\u70b9\u76f4\u63a5\u653e\u5165\u65b0\u6876
\n if (runBit == (fh & n)) {
\n ln = lastRun;
\n hn = null;
\n } else {
\n \/\/ \u62c6\u5206\u94fe\u8868\u4e3a\u4e24\u90e8\u5206
\n ln = null;
\n hn = lastRun;
\n for (p = f; p != lastRun; p = p.next) {
\n int b = p.hash & n;
\n Node<K,V> newNode = new Node<K,V>(p.hash, p.key, p.val, null);
\n if (b == runBit)
\n ln = (ln == null) ? newNode : ln.next = newNode;
\n else
\n hn = (hn == null) ? newNode : hn.next = newNode;
\n }
\n }
\n \/\/ \u5c06\u62c6\u5206\u540e\u7684\u94fe\u8868\u653e\u5165\u65b0\u6876
\n setTabAt(nextTab, i, ln);
\n setTabAt(nextTab, i + n, hn);
\n \/\/ \u6807\u8bb0\u5f53\u524d\u6876\u5df2\u8fc1\u79fb
\n setTabAt(tab, i, fwd);
\n advance = true;
\n } else if (f instanceof TreeBin) { \/\/ \u5934\u8282\u70b9\u662f\u7ea2\u9ed1\u6811
\n TreeBin<K,V> t = (TreeBin<K,V>)f;
\n TreeNode<K,V> lo = null, loTail = null;
\n TreeNode<K,V> hi = null, hiTail = null;
\n int lc = 0, hc = 0;
\n \/\/ \u904d\u5386\u7ea2\u9ed1\u6811\u8282\u70b9，\u62c6\u5206\u5230\u65b0\u6876
\n for (Node<K,V> e = t.first; e != null; e = e.next) {
\n int h = e.hash;
\n TreeNode<K,V> p = new TreeNode<K,V>(h, e.key, e.val, null, null);
\n if ((h & n) == 0) {
\n if (loTail == null) lo = p;
\n else loTail.next = p;
\n loTail = p;
\n lc++;
\n } else {
\n if (hiTail == null) hi = p;
\n else hiTail.next = p;
\n hiTail = p;
\n hc++;
\n }
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u9700\u8981\u8f6c\u6362\u4e3a\u94fe\u8868
\n ln = (lc <= 6) ? untreeify(lo) : (hc != 0) ? new TreeBin<K,V>(lo) : t;
\n hn = (hc <= 6) ? untreeify(hi) : (lc != 0) ? new TreeBin<K,V>(hi) : t;
\n \/\/ \u653e\u5165\u65b0\u6876
\n setTabAt(nextTab, i, ln);
\n setTabAt(nextTab, i + n, hn);
\n \/\/ \u6807\u8bb0\u5f53\u524d\u6876\u5df2\u8fc1\u79fb
\n setTabAt(tab, i, fwd);
\n advance = true;
\n }
\n }
\n }
\n }
\n }
\n}<\/p>\n
\/\/ \u8f85\u52a9\u65b9\u6cd5：CAS \u8bbe\u7f6e\u6876\u7684\u8282\u70b9
\nprivate void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
\n U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
\n}<\/p>\n
\u8ba1\u7b97\u8fc1\u79fb\u6b65\u957f：
\n\u6839\u636e CPU \u6838\u5fc3\u6570\u548c\u539f\u6570\u7ec4\u957f\u5ea6，\u786e\u5b9a\u6bcf\u4e2a\u7ebf\u7a0b\u7684\u8fc1\u79fb\u6876\u6570\u91cf\u3002<\/p>\n<\/li>\n
\u521d\u59cb\u5316\u65b0\u6570\u7ec4：
\n\u521b\u5efa\u6269\u5bb9\u540e\u7684\u65b0\u6570\u7ec4（\u5bb9\u91cf\u7ffb\u500d），\u6807\u8bb0\u8fc1\u79fb\u72b6\u6001\u3002<\/p>\n<\/li>\n
\u521b\u5efa ForwardingNode：
\n\u6807\u8bb0\u6876\u8fc1\u79fb\u72b6\u6001，\u7528\u4e8e\u91cd\u5b9a\u5411\u8bbf\u95ee\u3002<\/p>\n<\/li>\n
\u5206\u914d\u8fc1\u79fb\u8303\u56f4：
\n\u901a\u8fc7\u00a0transferIndex\u00a0\u5206\u914d\u7ebf\u7a0b\u7684\u8fc1\u79fb\u6876\u8303\u56f4，\u907f\u514d\u7ade\u4e89\u3002<\/p>\n<\/li>\n
\u5904\u7406\u7a7a\u6876：
\n\u6807\u8bb0\u4e3a\u7a7a\u6876\u4e3a\u8fc1\u79fb\u4e2d（fwd\u00a0）\u3002<\/p>\n<\/li>\n
\u5904\u7406\u8fc1\u79fb\u4e2d\u6876：
\n\u8df3\u8fc7\u5df2\u6807\u8bb0\u4e3a\u00a0MOVED\u00a0\u7684\u6876\u3002<\/p>\n<\/li>\n
\u62c6\u5206\u94fe\u8868 \/ \u7ea2\u9ed1\u6811：
\n\u52a0\u9501\u540e\u62c6\u5206\u8282\u70b9，\u5206\u522b\u653e\u5165\u65b0\u6570\u7ec4\u7684\u539f\u4f4d\u7f6e\u548c\u6269\u5bb9\u4f4d\u7f6e\u3002<\/p>\n<\/li>\n
\u6807\u8bb0\u8fc1\u79fb\u5b8c\u6210：
\n\u66ff\u6362\u539f\u6570\u7ec4\u4e3a\u65b0\u6570\u7ec4，\u66f4\u65b0\u6269\u5bb9\u9608\u503c\u3002<\/p>\n<\/li>\n
\u7ef4\u62a4\u4e00\u4e2a\u00a0segment\u00a0\u6570\u7ec4，\u6bcf\u4e2a\u00a0segment\u00a0\u5bf9\u5e94\u4e00\u628a\u9501<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/08\/20250814061550-689d7f1620a9c.png\")
<\/p>\n
\/\/ \u6700\u5927 Segment \u6570\u91cf（\u5fc5\u987b\u662f 2 \u7684\u5e42，\u4e14\u4e0d\u8d85\u8fc7 1<<16）
\nstatic final int MAX_SEGMENTS = 1 << 16;
\n\/\/ \u6bcf\u4e2a Segment \u4e2d\u54c8\u5e0c\u8868\u7684\u6700\u5c0f\u5bb9\u91cf（\u5fc5\u987b\u662f 2 \u7684\u5e42，\u9ed8\u8ba4 2）
\nstatic final int MIN_SEGMENT_TABLE_CAPACITY = 2; <\/p>\n
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
\n \/\/ 1. \u53c2\u6570\u5408\u6cd5\u6027\u6821\u9a8c
\n if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) {
\n throw new IllegalArgumentException();
\n }
\n \/\/ 2. \u9650\u5236 concurrencyLevel \u7684\u6700\u5927\u503c
\n if (concurrencyLevel > MAX_SEGMENTS) {
\n concurrencyLevel = MAX_SEGMENTS;
\n }
\n \/\/ 3. \u8ba1\u7b97 Segment \u6570\u7ec4\u7684\u5927\u5c0f（ssize）：\u5fc5\u987b\u662f 2 \u7684\u5e42
\n int sshift = 0; \/\/ \u5de6\u79fb\u6b21\u6570
\n int ssize = 1; \/\/ Segment \u6570\u7ec4\u7684\u521d\u59cb\u5927\u5c0f（\u81f3\u5c11\u4e3a 1）
\n while (ssize < concurrencyLevel) {
\n ++sshift;
\n ssize <<= 1; \/\/ \u5de6\u79fb 1 \u4f4d（\u4e58\u4ee5 2），\u76f4\u5230 ssize >= concurrencyLevel
\n }
\n \/\/ 4. \u8ba1\u7b97 segmentShift \u548c segmentMask
\n this.segmentShift = 32 – sshift; \/\/ \u7528\u4e8e\u8ba1\u7b97 Segment \u4e0b\u6807
\n this.segmentMask = ssize – 1; \/\/ \u7528\u4e8e\u8ba1\u7b97 Segment \u4e0b\u6807\u7684\u63a9\u7801
\n \/\/ 5. \u9650\u5236 initialCapacity \u7684\u6700\u5927\u503c
\n if (initialCapacity > MAXIMUM_CAPACITY) {
\n initialCapacity = MAXIMUM_CAPACITY;
\n }
\n \/\/ 6. \u8ba1\u7b97\u6bcf\u4e2a Segment \u7684\u5bb9\u91cf（cap）
\n int c = initialCapacity \/ ssize; \/\/ \u5e73\u5747\u6bcf\u4e2a Segment \u7684\u5bb9\u91cf
\n if (c * ssize < initialCapacity) {
\n ++c; \/\/ \u5411\u4e0a\u53d6\u6574
\n }
\n int cap = MIN_SEGMENT_TABLE_CAPACITY; \/\/ \u6bcf\u4e2a Segment \u7684\u6700\u5c0f\u5bb9\u91cf
\n while (cap < c) {
\n cap <<= 1; \/\/ \u5de6\u79fb 1 \u4f4d（\u4e58\u4ee5 2），\u76f4\u5230 cap >= c
\n }
\n \/\/ 7. \u521b\u5efa\u7b2c\u4e00\u4e2a Segment（s0）
\n Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
\n (HashEntry<K,V>[])new HashEntry[cap]);
\n \/\/ 8. \u521b\u5efa Segment \u6570\u7ec4（ss）
\n Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
\n \/\/ 9. \u521d\u59cb\u5316 Segment \u6570\u7ec4\u7684\u7b2c\u4e00\u4e2a\u5143\u7d20（\u6709\u5e8f\u5199，\u907f\u514d\u6307\u4ee4\u91cd\u6392）
\n UNSAFE.putOrderedObject(ss, SBASE, s0);
\n this.segments = ss; \/\/ \u8d4b\u503c\u7ed9\u5168\u5c40\u53d8\u91cf
\n}<\/p>\n
\u53c2\u6570\u6821\u9a8c：
\n\u786e\u4fdd\u00a0loadFactor\u3001initialCapacity\u3001concurrencyLevel\u00a0\u5408\u6cd5\u3002<\/p>\n<\/li>\n
\u9650\u5236\u5e76\u53d1\u7ea7\u522b：
\nconcurrencyLevel\u00a0\u8d85\u8fc7\u6700\u5927\u503c\u65f6，\u622a\u65ad\u4e3a\u00a0MAX_SEGMENTS\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97 Segment \u6570\u7ec4\u5927\u5c0f：
\n\u627e\u5230\u5927\u4e8e\u7b49\u4e8e\u00a0concurrencyLevel\u00a0\u7684\u6700\u5c0f\u00a02 \u7684\u5e42（ssize\u00a0）\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97\u54c8\u5e0c\u504f\u79fb\u91cf：
\n\u901a\u8fc7\u00a0segmentShift\u00a0\u548c\u00a0segmentMask\u00a0\u5b9a\u4f4d\u00a0Segment\u3002<\/p>\n<\/li>\n
\u9650\u5236\u521d\u59cb\u5bb9\u91cf：
\ninitialCapacity\u00a0\u8d85\u8fc7\u6700\u5927\u503c\u65f6，\u622a\u65ad\u4e3a\u00a0MAXIMUM_CAPACITY\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97 Segment \u5bb9\u91cf：
\n\u6bcf\u4e2a\u00a0Segment\u00a0\u7684\u5bb9\u91cf（cap\u00a0）\u662f\u00a02 \u7684\u5e42，\u81f3\u5c11\u4e3a\u00a0MIN_SEGMENT_TABLE_CAPACITY\u3002<\/p>\n<\/li>\n
\u521b\u5efa\u7b2c\u4e00\u4e2a Segment：
\n\u521d\u59cb\u5316\u7b2c\u4e00\u4e2a\u00a0Segment，\u5305\u542b\u54c8\u5e0c\u8868\u548c\u6269\u5bb9\u9608\u503c\u3002<\/p>\n<\/li>\n
\u521b\u5efa Segment \u6570\u7ec4：
\n\u521d\u59cb\u5316\u00a0Segment\u00a0\u6570\u7ec4，\u5927\u5c0f\u4e3a\u00a0ssize\u3002<\/p>\n<\/li>\n
\u6709\u5e8f\u5199\u5165\u7b2c\u4e00\u4e2a Segment：
\n\u901a\u8fc7\u00a0UNSAFE\u00a0\u786e\u4fdd\u7ebf\u7a0b\u5b89\u5168，\u907f\u514d\u6307\u4ee4\u91cd\u6392\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97 segmentShift \u548c segmentMask<\/p>\n
this.segmentShift = 32 – sshift;
\nthis.segmentMask = ssize – 1;<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/08\/20250814061550-689d7f16aa9bd.png\")
<\/p>\n
public V put(K key, V value) {
\n \/\/ 1. \u6821\u9a8c value \u4e0d\u4e3a null（JDK 7 \u4e0d\u5141\u8bb8 value \u4e3a null）
\n if (value == null) {
\n throw new NullPointerException();
\n }
\n \/\/ 2. \u8ba1\u7b97 key \u7684\u54c8\u5e0c\u503c
\n int hash = hash(key);
\n \/\/ 3. \u8ba1\u7b97 key \u5bf9\u5e94\u7684 Segment \u4e0b\u6807
\n int j = (hash >>> segmentShift) & segmentMask;
\n \/\/ 4. \u83b7\u53d6\u6216\u521b\u5efa\u5bf9\u5e94\u7684 Segment
\n Segment<K,V> s;
\n if ((s = (Segment<K,V>)UNSAFE.getObject(
\n segments, (j << SSHIFT) + SBASE)) == null) {
\n \/\/ \u82e5 Segment \u4e3a null，\u901a\u8fc7 ensureSegment \u5b89\u5168\u521b\u5efa
\n s = ensureSegment(j);
\n }
\n \/\/ 5. \u8c03\u7528 Segment \u7684 put \u65b9\u6cd5\u63d2\u5165\u6570\u636e
\n return s.put(key, hash, value, false);
\n}<\/p>\n
\u6821\u9a8c\u00a0value：
\nvalue\u00a0\u4e3a\u00a0null\u00a0\u65f6\u629b\u51fa\u5f02\u5e38\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97\u54c8\u5e0c\u503c：
\n\u4e8c\u6b21\u54c8\u5e0c\u4f18\u5316，\u51cf\u5c11\u51b2\u7a81\u3002<\/p>\n<\/li>\n
\u5b9a\u4f4d\u00a0Segment：
\n\u901a\u8fc7\u00a0segmentShift\u00a0\u548c\u00a0segmentMask\u00a0\u8ba1\u7b97\u00a0Segment\u00a0\u4e0b\u6807\u3002<\/p>\n<\/li>\n
\u83b7\u53d6\u6216\u521b\u5efa\u00a0Segment：
\n\u7528\u00a0UNSAFE\u00a0\u76f4\u63a5\u8bbf\u95ee\u00a0Segment\u00a0\u6570\u7ec4；\u82e5\u4e3a\u00a0null，\u901a\u8fc7\u00a0ensureSegment\u00a0\u5b89\u5168\u521b\u5efa\u3002<\/p>\n<\/li>\n
\u8c03\u7528\u00a0Segment\u00a0\u7684\u00a0put：
\n\u8fdb\u5165\u00a0Segment\u00a0\u5185\u90e8\u7684\u9501\u903b\u8f91，\u63d2\u5165\u952e\u503c\u5bf9\u3002<\/p>\n<\/li>\n
segment\u7ee7\u627f\u4e86\u53ef\u91cd\u5165\u9501（ReentrantLock），\u5b83\u7684put\u65b9\u6cd5\u4e3a<\/p>\n
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
\n \/\/ 1. \u5c1d\u8bd5\u52a0\u9501（\u975e\u963b\u585e\u9501）
\n HashEntry<K,V> node = tryLock() ? null :
\n \/\/ \u52a0\u9501\u5931\u8d25，\u8fdb\u5165\u626b\u63cf\u5e76\u52a0\u9501\u6d41\u7a0b（\u6700\u591a\u5c1d\u8bd5 64 \u6b21）
\n scanAndLockForPut(key, hash, value);<\/p>\n
\/\/ 2. \u52a0\u9501\u6210\u529f\u540e，\u6267\u884c\u63d2\u5165\u903b\u8f91
\n V oldValue;
\n try {
\n HashEntry<K,V>[] tab = table; \/\/ \u5f53\u524d Segment \u7684\u54c8\u5e0c\u8868
\n int index = (tab.length – 1) & hash; \/\/ \u8ba1\u7b97\u6876\u4e0b\u6807
\n HashEntry<K,V> first = entryAt(tab, index); \/\/ \u83b7\u53d6\u6876\u7684\u5934\u8282\u70b9<\/p>\n
\/\/ 3. \u904d\u5386\u6876\u7684\u94fe\u8868，\u67e5\u627e\u6216\u63d2\u5165\u8282\u70b9
\n for (HashEntry<K,V> e = first;;) {
\n if (e != null) { \/\/ \u6876\u4e0d\u4e3a\u7a7a
\n K k;
\n \/\/ 3.1 \u627e\u5230\u76f8\u540c key \u7684\u8282\u70b9，\u66f4\u65b0\u503c
\n if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
\n oldValue = e.value;
\n if (!onlyIfAbsent) { \/\/ \u662f\u5426\u4ec5\u5728\u4e0d\u5b58\u5728\u65f6\u63d2\u5165
\n e.value = value;
\n ++modCount; \/\/ \u8bb0\u5f55\u7ed3\u6784\u4fee\u6539\u6b21\u6570
\n }
\n break;
\n }
\n e = e.next; \/\/ \u904d\u5386\u4e0b\u4e00\u4e2a\u8282\u70b9
\n } else { \/\/ \u6876\u4e3a\u7a7a，\u63d2\u5165\u65b0\u8282\u70b9
\n if (node != null) { \/\/ \u590d\u7528 scanAndLockForPut \u521b\u5efa\u7684\u8282\u70b9
\n node.setNext(first);
\n } else { \/\/ \u521b\u5efa\u65b0\u8282\u70b9
\n node = new HashEntry<K,V>(hash, key, value, first);
\n }
\n int c = count + 1; \/\/ \u5f53\u524d Segment \u7684\u5143\u7d20\u6570\u91cf
\n \/\/ \u68c0\u67e5\u662f\u5426\u9700\u8981\u6269\u5bb9（\u8d85\u8fc7\u8d1f\u8f7d\u56e0\u5b50）
\n if (c > threshold && tab.length < MAXIMUM_CAPACITY) {
\n \/\/ \u6269\u5bb9\u5e76\u8fc1\u79fb\u6570\u636e
\n rehash(node);
\n } else {
\n \/\/ \u63d2\u5165\u65b0\u8282\u70b9\u5230\u6876\u7684\u5934\u90e8
\n setEntryAt(tab, index, node);
\n }
\n ++modCount;
\n count = c; \/\/ \u66f4\u65b0\u5143\u7d20\u6570\u91cf
\n oldValue = null;
\n break;
\n }
\n }
\n } finally {
\n \/\/ 4. \u91ca\u653e\u9501
\n unlock();
\n }
\n return oldValue;
\n}<\/p>\n
\u5c1d\u8bd5\u52a0\u9501：
\n\u975e\u963b\u585e\u52a0\u9501\u5931\u8d25\u540e，\u8fdb\u5165\u00a0scanAndLockForPut\u00a0\u6d41\u7a0b（\u6700\u591a\u5c1d\u8bd5 64 \u6b21 ）\u3002<\/p>\n<\/li>\n
\u904d\u5386\u94fe\u8868\u67e5\u627e\u8282\u70b9：
\n\u627e\u5230\u76f8\u540c\u00a0key\u00a0\u5219\u66f4\u65b0\u503c，\u5426\u5219\u51c6\u5907\u63d2\u5165\u65b0\u8282\u70b9\u3002<\/p>\n<\/li>\n
\u63d2\u5165\u65b0\u8282\u70b9：
\n\u6876\u4e3a\u7a7a\u65f6\u63d2\u5165\u65b0\u8282\u70b9，\u68c0\u67e5\u662f\u5426\u9700\u8981\u6269\u5bb9（rehash\u00a0）\u3002<\/p>\n<\/li>\n
\u6269\u5bb9\u4e0e\u8fc1\u79fb：
\n\u8d85\u8fc7\u8d1f\u8f7d\u56e0\u5b50\u65f6，\u6269\u5bb9\u4e3a\u539f\u5bb9\u91cf\u7684 2 \u500d，\u62c6\u5206\u5e76\u8fc1\u79fb\u94fe\u8868\u3002<\/p>\n<\/li>\n
\u91ca\u653e\u9501：
\n\u64cd\u4f5c\u5b8c\u6210\u540e\u91ca\u653e\u9501，\u4fdd\u8bc1\u7ebf\u7a0b\u5b89\u5168<\/p>\n<\/li>\n
\u627e\u5230\u94fe\u8868\u4e2d\u8fde\u7eed\u76f8\u540c\u4e0b\u6807\u7684\u6700\u957f\u5b50\u94fe\u8868（lastRun\u00a0），\u76f4\u63a5\u8fc1\u79fb，\u51cf\u5c11\u8282\u70b9\u590d\u5236\u6b21\u6570，\u63d0\u5347\u6269\u5bb9\u6548\u7387\u3002<\/p>\n
private void rehash(HashEntry<K,V> node) {
\n \/\/ 1. \u4fdd\u5b58\u65e7\u54c8\u5e0c\u8868\u6570\u636e
\n HashEntry<K,V>[] oldTable = table;
\n int oldCapacity = oldTable.length;
\n \/\/ 2. \u8ba1\u7b97\u65b0\u5bb9\u91cf（\u6269\u5bb9\u4e3a\u539f\u5bb9\u91cf\u7684 2 \u500d）
\n int newCapacity = oldCapacity << 1;
\n \/\/ 3. \u66f4\u65b0\u6269\u5bb9\u9608\u503c（\u65b0\u5bb9\u91cf * \u8d1f\u8f7d\u56e0\u5b50）
\n threshold = (int)(newCapacity * loadFactor);
\n \/\/ 4. \u521b\u5efa\u65b0\u54c8\u5e0c\u8868
\n HashEntry<K,V>[] newTable = (HashEntry<K,V>[]) new HashEntry[newCapacity];
\n int sizeMask = newCapacity – 1; \/\/ \u65b0\u7684\u63a9\u7801（\u7528\u4e8e\u8ba1\u7b97\u6876\u4e0b\u6807）<\/p>\n
\/\/ 5. \u904d\u5386\u65e7\u54c8\u5e0c\u8868，\u8fc1\u79fb\u6570\u636e\u5230\u65b0\u54c8\u5e0c\u8868
\n for (int i = 0; i < oldCapacity; ++i) {
\n HashEntry<K,V> e = oldTable[i]; \/\/ \u5f53\u524d\u6876\u7684\u5934\u8282\u70b9
\n if (e != null) { \/\/ \u6876\u4e0d\u4e3a\u7a7a
\n HashEntry<K,V> next = e.next; \/\/ \u4e0b\u4e00\u4e2a\u8282\u70b9
\n int idx = e.hash & sizeMask; \/\/ \u8ba1\u7b97\u65b0\u6876\u4e0b\u6807<\/p>\n
\/\/ 5.1 \u6876\u4e2d\u53ea\u6709\u4e00\u4e2a\u8282\u70b9（\u94fe\u8868\u957f\u5ea6\u4e3a 1）
\n if (next == null) {
\n newTable[idx] = e;
\n } else {
\n \/\/ 5.2 \u6876\u4e2d\u6709\u591a\u4e2a\u8282\u70b9，\u590d\u7528\u8fde\u7eed\u76f8\u540c\u4e0b\u6807\u7684\u8282\u70b9
\n HashEntry<K,V> lastRun = e; \/\/ \u8bb0\u5f55\u8fde\u7eed\u76f8\u540c\u4e0b\u6807\u7684\u6700\u540e\u4e00\u4e2a\u8282\u70b9
\n int lastIdx = idx; \/\/ \u8bb0\u5f55\u5f53\u524d\u4e0b\u6807<\/p>\n
\/\/ \u904d\u5386\u94fe\u8868，\u627e\u5230\u8fde\u7eed\u76f8\u540c\u4e0b\u6807\u7684\u6700\u957f\u5b50\u94fe\u8868
\n for (HashEntry<K,V> last = next; last != null; last = last.next) {
\n int k = last.hash & sizeMask;
\n if (k != lastIdx) {
\n lastIdx = k;
\n lastRun = last;
\n }
\n }<\/p>\n
\/\/ \u5c06\u8fde\u7eed\u76f8\u540c\u4e0b\u6807\u7684\u5b50\u94fe\u8868\u76f4\u63a5\u653e\u5165\u65b0\u6876
\n newTable[lastIdx] = lastRun;<\/p>\n
\/\/ 5.3 \u904d\u5386\u5269\u4f59\u8282\u70b9，\u62c6\u5206\u5230\u65b0\u6876
\n for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
\n V v = p.value;
\n int h = p.hash;
\n int k = h & sizeMask;
\n \/\/ \u63d2\u5165\u5230\u65b0\u6876\u7684\u5934\u90e8（\u5934\u63d2\u6cd5）
\n HashEntry<K,V> n = newTable[k];
\n newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
\n }
\n }
\n }
\n }<\/p>\n
\/\/ 6. \u5904\u7406\u5f53\u524d\u63d2\u5165\u7684\u65b0\u8282\u70b9（\u6269\u5bb9\u65f6\u88ab\u6682\u65f6\u4fdd\u5b58\u7684\u8282\u70b9）
\n int nodeIndex = node.hash & sizeMask; \/\/ \u8ba1\u7b97\u65b0\u4e0b\u6807
\n node.setNext(newTable[nodeIndex]); \/\/ \u63d2\u5165\u5230\u65b0\u6876\u7684\u5934\u90e8
\n newTable[nodeIndex] = node; \/\/ \u66f4\u65b0\u65b0\u6876\u7684\u5934\u8282\u70b9<\/p>\n
\/\/ 7. \u66ff\u6362\u4e3a\u65b0\u54c8\u5e0c\u8868
\n table = newTable;
\n}<\/p>\n
\u4fdd\u5b58\u65e7\u8868\u6570\u636e：
\n\u8bb0\u5f55\u65e7\u54c8\u5e0c\u8868\u7684\u5f15\u7528\u548c\u5bb9\u91cf\u3002<\/p>\n<\/li>\n
\u8ba1\u7b97\u65b0\u5bb9\u91cf：
\n\u6269\u5bb9\u4e3a\u539f\u5bb9\u91cf\u7684 2 \u500d（oldCapacity << 1\u00a0）\u3002<\/p>\n<\/li>\n
\u66f4\u65b0\u6269\u5bb9\u9608\u503c：
\n\u65b0\u5bb9\u91cf\u4e58\u4ee5\u8d1f\u8f7d\u56e0\u5b50，\u4f5c\u4e3a\u4e0b\u4e00\u6b21\u6269\u5bb9\u7684\u89e6\u53d1\u6761\u4ef6\u3002<\/p>\n<\/li>\n
\u521b\u5efa\u65b0\u54c8\u5e0c\u8868：
\n\u521d\u59cb\u5316\u65b0\u54c8\u5e0c\u8868，\u5bb9\u91cf\u4e3a\u00a0newCapacity\u3002<\/p>\n<\/li>\n
\u8fc1\u79fb\u65e7\u8868\u6570\u636e：<\/p>\n
\u63d2\u5165\u65b0\u8282\u70b9：
\n\u5c06\u6269\u5bb9\u65f6\u6682\u65f6\u4fdd\u5b58\u7684\u65b0\u8282\u70b9\u63d2\u5165\u5230\u65b0\u54c8\u5e0c\u8868\u3002<\/p>\n<\/li>\n
\u66ff\u6362\u54c8\u5e0c\u8868：
\n\u5c06\u00a0Segment\u00a0\u7684\u54c8\u5e0c\u8868\u66ff\u6362\u4e3a\u65b0\u54c8\u5e0c\u8868，\u5b8c\u6210\u6269\u5bb9\u3002<\/p>\n<\/li>\n
\u6bcf\u4e2a\u00a0Segment\u00a0\u72ec\u7acb\u5b58\u50a8\u6570\u636e，get\u00a0\u65f6\u53ea\u9700\u8bbf\u95ee\u5bf9\u5e94\u00a0Segment，\u65e0\u9700\u52a0\u9501\u3002<\/p>\n
\u901a\u8fc7\u00a0UNSAFE.getObjectVolatile\u00a0\u4fdd\u8bc1\u00a0Segment\u00a0\u548c\u00a0HashEntry\u00a0\u7684\u53ef\u89c1\u6027，\u907f\u514d\u810f\u8bfb\u3002<\/p>\n
public V get(Object key) {
\n \/\/ 1. \u8ba1\u7b97 key \u7684\u54c8\u5e0c\u503c
\n int h = hash(key);
\n \/\/ 2. \u8ba1\u7b97 key \u5bf9\u5e94\u7684 Segment \u504f\u79fb\u91cf
\n long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
\n \/\/ 3. \u83b7\u53d6\u5bf9\u5e94\u7684 Segment
\n Segment<K,V> s = (Segment<K,V>) UNSAFE.getObjectVolatile(segments, u);
\n HashEntry<K,V>[] tab;
\n \/\/ 4. \u68c0\u67e5 Segment \u548c\u54c8\u5e0c\u8868\u662f\u5426\u4e3a\u7a7a
\n if (s != null && (tab = s.table) != null) {
\n \/\/ 5. \u8ba1\u7b97\u6876\u4e0b\u6807，\u5e76\u83b7\u53d6\u6876\u7684\u5934\u8282\u70b9
\n long t = (((long)(tab.length – 1) & h) << TSHIFT) + TBASE;
\n for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile(tab, t);
\n e != null;
\n e = e.next) { \/\/ \u904d\u5386\u94fe\u8868
\n K k;
\n \/\/ 6. \u627e\u5230\u76f8\u540c key \u7684\u8282\u70b9，\u8fd4\u56de\u5bf9\u5e94\u503c
\n if ((k = e.key) == key || (e.hash == h && key.equals(k))) {
\n return e.value;
\n }
\n }
\n }
\n return null; \/\/ \u672a\u627e\u5230\u5bf9\u5e94 key，\u8fd4\u56de null
\n}<\/p>\n
\u8ba1\u7b97\u54c8\u5e0c\u503c：
\n\u4e8c\u6b21\u54c8\u5e0c\u4f18\u5316，\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002<\/p>\n<\/li>\n
\u5b9a\u4f4d Segment：
\n\u901a\u8fc7\u54c8\u5e0c\u503c\u548c\u00a0Segment\u00a0\u6570\u7ec4\u53c2\u6570，\u8ba1\u7b97\u5185\u5b58\u504f\u79fb\u91cf，\u83b7\u53d6\u5bf9\u5e94\u00a0Segment\u3002<\/p>\n<\/li>\n
\u68c0\u67e5\u975e\u7a7a：
\n\u786e\u4fdd\u00a0Segment\u00a0\u548c\u54c8\u5e0c\u8868\u5df2\u521d\u59cb\u5316，\u907f\u514d\u7a7a\u6307\u9488\u3002<\/p>\n<\/li>\n
\u5b9a\u4f4d\u6876\u5e76\u904d\u5386\u94fe\u8868：
\n\u8ba1\u7b97\u6876\u4e0b\u6807，\u83b7\u53d6\u5934\u8282\u70b9，\u904d\u5386\u94fe\u8868\u67e5\u627e\u5339\u914d\u7684\u00a0key\u3002<\/p>\n<\/li>\n
\u5339\u914d\u8282\u70b9\u5e76\u8fd4\u56de\u503c：
\n\u627e\u5230\u00a0key\u00a0\u548c\u00a0hash\u00a0\u90fd\u5339\u914d\u7684\u8282\u70b9，\u8fd4\u56de\u5bf9\u5e94\u503c；\u5426\u5219\u8fd4\u56de\u00a0null\u3002<\/p>\n<\/li>\n
\/\/ \u91cd\u8bd5\u6b21\u6570\u9608\u503c：\u8d85\u8fc7\u8be5\u6b21\u6570\u5219\u52a0\u9501\u6240\u6709 Segment
\nstatic final int RETRIES_BEFORE_LOCK = 2; <\/p>\n
public int size() {
\n \/\/ 1. \u521d\u59cb\u5316\u53d8\u91cf
\n final Segment<K,V>[] segments = this.segments;
\n int size; \/\/ \u6700\u7ec8\u8fd4\u56de\u7684\u5143\u7d20\u6570\u91cf
\n boolean overflow; \/\/ \u662f\u5426\u6ea2\u51fa 32 \u4f4d\u6574\u6570
\n long sum; \/\/ \u6240\u6709 Segment \u7684 modCount \u4e4b\u548c
\n long last = 0L; \/\/ \u4e0a\u4e00\u6b21\u8ba1\u7b97\u7684 sum
\n int retries = -1; \/\/ \u91cd\u8bd5\u6b21\u6570（\u521d\u59cb\u4e3a -1，\u7b2c\u4e00\u6b21\u5faa\u73af\u4e0d\u89c6\u4e3a\u91cd\u8bd5）<\/p>\n
try {
\n for (;;) { \/\/ \u65e0\u9650\u5faa\u73af，\u76f4\u5230\u83b7\u53d6\u7a33\u5b9a\u7ed3\u679c
\n \/\/ 2. \u68c0\u67e5\u662f\u5426\u9700\u8981\u52a0\u9501\u6240\u6709 Segment
\n if (retries++ == RETRIES_BEFORE_LOCK) {
\n \/\/ \u904d\u5386\u6240\u6709 Segment，\u52a0\u9501（\u786e\u4fdd Segment \u5df2\u521b\u5efa）
\n for (int j = 0; j < segments.length; ++j) {
\n ensureSegment(j).lock(); \/\/ \u52a0\u9501，force creation
\n }
\n }<\/p>\n
\/\/ 3. \u91cd\u7f6e\u8ba1\u7b97\u53c2\u6570
\n sum = 0L;
\n size = 0;
\n overflow = false;<\/p>\n
\/\/ 4. \u904d\u5386\u6240\u6709 Segment，\u7d2f\u52a0\u5143\u7d20\u6570\u91cf
\n for (int j = 0; j < segments.length; ++j) {
\n Segment<K,V> seg = segmentAt(segments, j);
\n if (seg != null) {
\n sum += seg.modCount; \/\/ \u7d2f\u52a0 modCount（\u8bb0\u5f55\u7ed3\u6784\u53d8\u5316）
\n int c = seg.count; \/\/ \u5f53\u524d Segment \u7684\u5143\u7d20\u6570\u91cf
\n if (c < 0 || (size += c) < 0) {
\n overflow = true; \/\/ \u6ea2\u51fa\u5224\u65ad
\n }
\n }
\n }<\/p>\n
\/\/ 5. \u68c0\u67e5\u4e24\u6b21\u8ba1\u7b97\u7ed3\u679c\u662f\u5426\u4e00\u81f4
\n if (sum == last) { \/\/ \u82e5 sum \u4e0e\u4e0a\u4e00\u6b21\u76f8\u540c，\u8bf4\u660e\u65e0\u7ed3\u6784\u53d8\u5316
\n break;
\n }
\n last = sum; \/\/ \u8bb0\u5f55\u5f53\u524d sum，\u7528\u4e8e\u4e0b\u6b21\u5bf9\u6bd4
\n }
\n } finally {
\n \/\/ 6. \u91ca\u653e\u6240\u6709 Segment \u7684\u9501（\u4ec5\u5f53\u52a0\u9501\u8fc7\u624d\u91ca\u653e）
\n if (retries > RETRIES_BEFORE_LOCK) {
\n for (int j = 0; j < segments.length; ++j) {
\n segmentAt(segments, j).unlock();
\n }
\n }
\n }<\/p>\n
\/\/ 7. \u5904\u7406\u6ea2\u51fa\u6216\u8fd4\u56de\u7ed3\u679c
\n return overflow ? Integer.MAX_VALUE : size;
\n}<\/p>\n
\/\/ \u8f85\u52a9\u65b9\u6cd5：\u83b7\u53d6\u6307\u5b9a\u4f4d\u7f6e\u7684 Segment（\u786e\u4fdd\u53ef\u89c1\u6027）
\nprivate Segment<K,V> segmentAt(Segment<K,V>[] segments, int j) {
\n return (Segment<K,V>) UNSAFE.getObjectVolatile(segments,
\n ((long)j << SSHIFT) + SBASE);
\n}<\/p>\n
\/\/ \u8f85\u52a9\u65b9\u6cd5：\u786e\u4fdd Segment \u5df2\u521b\u5efa（\u5ef6\u8fdf\u521d\u59cb\u5316）
\nprivate Segment<K,V> ensureSegment(int j) {
\n \/\/ … \u903b\u8f91\u4e0e\u4e4b\u524d\u89e3\u6790\u4e00\u81f4，\u786e\u4fdd Segment \u521b\u5efa …
\n}<\/p>\n
\u521d\u59cb\u5316\u53d8\u91cf：
\n\u5b9a\u4e49\u7ed3\u679c\u3001\u6ea2\u51fa\u6807\u8bb0\u3001modCount\u00a0\u7d2f\u52a0\u548c\u7b49\u53d8\u91cf\u3002<\/p>\n<\/li>\n
\u68c0\u67e5\u52a0\u9501\u6761\u4ef6：
\n\u91cd\u8bd5\u6b21\u6570\u8d85\u8fc7\u9608\u503c\u65f6，\u52a0\u9501\u6240\u6709\u00a0Segment，\u786e\u4fdd\u7ed3\u679c\u51c6\u786e\u3002<\/p>\n<\/li>\n
\u91cd\u7f6e\u8ba1\u7b97\u53c2\u6570：
\n\u6bcf\u6b21\u8ba1\u7b97\u524d\u6e05\u7a7a\u4e34\u65f6\u53d8\u91cf，\u907f\u514d\u5e72\u6270\u3002<\/p>\n<\/li>\n
\u904d\u5386\u7d2f\u52a0\u6570\u91cf：
\n\u904d\u5386\u6240\u6709\u00a0Segment，\u7d2f\u52a0\u00a0modCount\u00a0\u548c\u00a0count，\u68c0\u6d4b\u6ea2\u51fa\u3002<\/p>\n<\/li>\n
\u68c0\u67e5\u7ed3\u679c\u7a33\u5b9a\u6027：
\n\u82e5\u00a0modCount\u00a0\u4e4b\u548c\u7a33\u5b9a（\u4e24\u6b21\u8ba1\u7b97\u76f8\u540c ），\u8ba4\u4e3a\u7ed3\u679c\u51c6\u786e，\u8df3\u51fa\u5faa\u73af\u3002<\/p>\n<\/li>\n
\u91ca\u653e\u9501：
\n\u52a0\u9501\u540e\u9700\u91ca\u653e，\u907f\u514d\u6027\u80fd\u635f\u8017\u3002<\/p>\n<\/li>\n
\u8fd4\u56de\u7ed3\u679c：
\n\u6839\u636e\u6ea2\u51fa\u60c5\u51b5\u8fd4\u56de\u6700\u7ec8\u7ed3\u679c\u3002<\/p>\n<\/li>\n<\/p>\n
| \u5e95\u5c42\u6570\u636e\u7ed3\u6784<\/td>\n | \u7531Segment\u6570\u7ec4\u548cHashEntry\u6570\u7ec4\u7ec4\u6210，\u6bcf\u4e2aSegment\u7c7b\u4f3c\u4e8e\u4e00\u4e2a\u5c0f\u578b\u7684HashMap，Segment\u7ee7\u627f\u81eaReentrantLock，\u662f\u53ef\u91cd\u5165\u9501，HashEntry\u7ec4\u6210\u94fe\u8868\u6765\u5904\u7406\u54c8\u5e0c\u51b2\u7a81<\/td>\n | \u7531Node\u6570\u7ec4\u3001\u94fe\u8868\u548c\u7ea2\u9ed1\u6811\u7ec4\u6210，\u6570\u7ec4\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u662f\u4e00\u4e2aNode，\u5982\u679c\u94fe\u8868\u957f\u5ea6\u8d85\u8fc7\u9608\u503c（\u9ed8\u8ba4 8），\u4f1a\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u4ee5\u63d0\u5347\u67e5\u8be2\u6548\u7387<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u9501\u673a\u5236<\/td>\n | \u5206\u6bb5\u9501，\u6bcf\u4e2aSegment\u5bf9\u5e94\u4e00\u628a\u9501，\u591a\u7ebf\u7a0b\u8bbf\u95ee\u4e0d\u540cSegment\u65f6\u4e0d\u4f1a\u4ea7\u751f\u51b2\u7a81，\u63d0\u9ad8\u4e86\u5e76\u53d1\u5ea6，\u4f46\u9501\u7c92\u5ea6\u76f8\u5bf9\u8f83\u7c97\u3002\u5f53\u8fdb\u884c\u5199\u64cd\u4f5c\u65f6，\u9700\u8981\u9501\u5b9a\u5bf9\u5e94\u7684Segment<\/td>\n | \u9501\u7c92\u5ea6\u66f4\u7ec6，\u5f15\u5165\u4e86CAS\u64cd\u4f5c\u548cSynchronized\u5173\u952e\u5b57\u3002\u5728\u94fe\u8868\u8282\u70b9\u5c42\u9762，\u5bf9\u4e8e\u63d2\u5165\u3001\u66f4\u65b0\u7b49\u64cd\u4f5c，\u5148\u5c1d\u8bd5\u4f7f\u7528CAS\u64cd\u4f5c，\u5931\u8d25\u540e\u518d\u4f7f\u7528synchronized\u540c\u6b65\u4ee3\u7801\u5757\u9501\u5b9a\u5355\u4e2a\u94fe\u8868\u8282\u70b9\u6216\u7ea2\u9ed1\u6811<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u521d\u59cb\u5316\u65b9\u5f0f<\/td>\n | \u4e0d\u662f\u61d2\u60f0\u521d\u59cb\u5316，\u5728\u521b\u5efaConcurrentHashMap\u65f6，\u4f1a\u6839\u636e\u6307\u5b9a\u7684concurrencyLevel\u521d\u59cb\u5316Segment\u6570\u7ec4，\u6bcf\u4e2aSegment\u5185\u90e8\u7684HashEntry\u6570\u7ec4\u4e5f\u4f1a\u8fdb\u884c\u4e00\u5b9a\u7684\u521d\u59cb\u5316<\/td>\n | \u91c7\u7528\u61d2\u60f0\u521d\u59cb\u5316，\u5728\u9996\u6b21\u63d2\u5165\u5143\u7d20\u65f6\u624d\u4f1a\u521d\u59cb\u5316\u5e95\u5c42\u7684\u6570\u7ec4<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u6269\u5bb9\u673a\u5236<\/td>\n | \u5f53\u67d0\u4e2aSegment\u4e2d\u7684\u5143\u7d20\u6570\u91cf\u8d85\u8fc7\u5176\u8d1f\u8f7d\u56e0\u5b50\u5bf9\u5e94\u7684\u9608\u503c\u65f6，\u8be5Segment\u8fdb\u884c\u6269\u5bb9，\u6269\u5bb9\u65f6\u4f1a\u521b\u5efa\u4e00\u4e2a\u65b0\u7684HashEntry\u6570\u7ec4，\u7136\u540e\u5c06\u65e7\u6570\u7ec4\u4e2d\u7684\u5143\u7d20\u91cd\u65b0\u54c8\u5e0c\u5e76\u8fc1\u79fb\u5230\u65b0\u6570\u7ec4\u4e2d，\u91c7\u7528\u5934\u63d2\u6cd5，\u5728\u591a\u7ebf\u7a0b\u73af\u5883\u4e0b\u53ef\u80fd\u4f1a\u51fa\u73b0\u94fe\u8868\u6210\u73af\u95ee\u9898<\/td>\n | \u5f53\u6574\u4e2aConcurrentHashMap\u7684\u5143\u7d20\u6570\u91cf\u8d85\u8fc7\u8d1f\u8f7d\u56e0\u5b50\u5bf9\u5e94\u7684\u9608\u503c\u65f6，\u4f1a\u89e6\u53d1\u6269\u5bb9\u3002\u6269\u5bb9\u65f6\u91c7\u7528\u590d\u5236\u8fc1\u79fb\u7684\u65b9\u5f0f，\u5c06\u65e7\u6570\u7ec4\u4e2d\u7684\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\u4e2d，\u5e76\u4e14\u91c7\u7528\u5c3e\u63d2\u6cd5，\u907f\u514d\u4e86\u94fe\u8868\u6210\u73af\u95ee\u9898\u3002\u540c\u65f6，\u6269\u5bb9\u652f\u6301\u591a\u7ebf\u7a0b\u534f\u4f5c，\u901a\u8fc7ForwardingNode\u6807\u8bb0\u8282\u70b9，\u8ba9\u5176\u4ed6\u7ebf\u7a0b\u77e5\u9053\u8be5\u8282\u70b9\u6b63\u5728\u8fc1\u79fb<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u8bfb\u64cd\u4f5c<\/td>\n | \u672a\u52a0\u9501，\u901a\u8fc7UNSAFE\u65b9\u6cd5\u4fdd\u8bc1\u53ef\u89c1\u6027\u3002\u5728\u6269\u5bb9\u8fc7\u7a0b\u4e2d，\u5982\u679cget\u64cd\u4f5c\u5148\u4e8e\u6269\u5bb9\u53d1\u751f，\u5219\u4ece\u65e7\u8868\u53d6\u5185\u5bb9；\u5982\u679cget\u64cd\u4f5c\u540e\u4e8e\u6269\u5bb9\u53d1\u751f，\u5219\u4ece\u65b0\u8868\u53d6\u5185\u5bb9<\/td>\n | \u8bfb\u64cd\u4f5c\u5927\u90e8\u5206\u60c5\u51b5\u4e0b\u65e0\u9501，\u901a\u8fc7volatile\u5173\u952e\u5b57\u4fdd\u8bc1\u53ef\u89c1\u6027\u3002\u5728\u94fe\u8868\u4e0a\u67e5\u627e\u65f6\u76f4\u63a5\u904d\u5386，\u5728\u7ea2\u9ed1\u6811\u4e0a\u67e5\u627e\u65f6\u6309\u7167\u7ea2\u9ed1\u6811\u7684\u67e5\u627e\u7b97\u6cd5\u8fdb\u884c<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u5199\u64cd\u4f5c<\/td>\n | \u5bf9\u9700\u8981\u64cd\u4f5c\u7684Segment\u52a0\u9501，\u7136\u540e\u8fdb\u884c\u63d2\u5165\u3001\u66f4\u65b0\u7b49\u64cd\u4f5c\u3002\u5982\u679c\u5728\u4e00\u4e2aSegment\u5185\u94fe\u8868\u957f\u5ea6\u8fc7\u957f，\u4e0d\u4f1a\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811<\/td>\n | \u5148\u901a\u8fc7\u54c8\u5e0c\u503c\u786e\u5b9a\u8981\u64cd\u4f5c\u7684\u6570\u7ec4\u7d22\u5f15\u4f4d\u7f6e，\u82e5\u8be5\u4f4d\u7f6e\u4e3a\u7a7a，\u4f7f\u7528CAS\u64cd\u4f5c\u63d2\u5165\u65b0\u8282\u70b9；\u82e5\u4e0d\u4e3a\u7a7a，\u5224\u65ad\u662f\u94fe\u8868\u8fd8\u662f\u7ea2\u9ed1\u6811，\u7136\u540e\u91c7\u7528\u4e0d\u540c\u7684\u65b9\u5f0f\u63d2\u5165，\u5f53\u94fe\u8868\u957f\u5ea6\u8fbe\u5230\u9608\u503c（\u9ed8\u8ba4 8）\u4e14\u6570\u7ec4\u957f\u5ea6\u5927\u4e8e 64 \u65f6，\u4f1a\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u8ba1\u7b97\u5143\u7d20\u4e2a\u6570（size）<\/td>\n | \u5148\u4e0d\u52a0\u9501\u8ba1\u7b97\u4e24\u6b21modCount\u4e4b\u548c\u4ee5\u53ca\u6bcf\u4e2aSegment\u7684\u5143\u7d20\u6570\u91cf\u603b\u548c，\u5982\u679c\u524d\u540e\u4e24\u6b21\u8ba1\u7b97\u7ed3\u679c\u4e00\u6837，\u8ba4\u4e3a\u4e2a\u6570\u6b63\u786e\u8fd4\u56de；\u5982\u679c\u4e0d\u4e00\u6837，\u8fdb\u884c\u91cd\u8bd5，\u91cd\u8bd5\u6b21\u6570\u8d85\u8fc7 3 \u6b21，\u5c06\u6240\u6709Segment\u9501\u4f4f，\u91cd\u65b0\u8ba1\u7b97\u4e2a\u6570\u8fd4\u56de<\/td>\n | \u901a\u8fc7\u7d2f\u52a0baseCount\u548ccounterCells\u6570\u7ec4\u4e2d\u6240\u6709CounterCell\u7684value\u503c\u6765\u8ba1\u7b97\u5143\u7d20\u4e2a\u6570\u3002\u5728\u591a\u7ebf\u7a0b\u5e76\u53d1\u4fee\u6539\u7684\u60c5\u51b5\u4e0b，\u7531\u4e8ecounterCells\u7684\u5b58\u5728，\u80fd\u8f83\u597d\u5730\u5904\u7406\u5e76\u53d1\u8ba1\u6570\u95ee\u9898<\/td>\n<\/tr>\n | ||||||||||||||||||||||||
| \u6027\u80fd\u7279\u70b9<\/td>\n | \u5728\u591a\u7ebf\u7a0b\u8bfb\u591a\u5199\u5c11\u7684\u573a\u666f\u4e0b，\u7531\u4e8e\u5206\u6bb5\u9501\u673a\u5236，\u5e76\u53d1\u6027\u80fd\u8f83\u597d，\u4f46\u5199\u64cd\u4f5c\u65f6\u9501\u7c92\u5ea6\u76f8\u5bf9\u8f83\u7c97，\u53ef\u80fd\u5b58\u5728\u7ade\u4e89\u3002\u521d\u59cb\u5316\u65f6\u4f1a\u5360\u7528\u4e00\u5b9a\u5185\u5b58<\/td>\n | \u5728\u591a\u7ebf\u7a0b\u8bfb\u5199\u573a\u666f\u4e0b\u6027\u80fd\u90fd\u6709\u8f83\u5927\u63d0\u5347，\u9501\u7c92\u5ea6\u66f4\u7ec6，CAS\u548cSynchronized\u7ed3\u5408\u51cf\u5c11\u4e86\u9501\u7ade\u4e89，\u5e76\u4e14\u91c7\u7528\u4e86\u7ea2\u9ed1\u6811\u4f18\u5316\u67e5\u8be2，\u5185\u5b58\u4f7f\u7528\u66f4\u9ad8\u6548，\u521d\u59cb\u5316\u65f6\u6309\u9700\u5206\u914d\u5185\u5b58<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
|