Java多线程系列--“JUC集合”04之 ConcurrentHashMap
概要
本章是JUC系列的ConcurrentHashMap篇。内容包括：
ConcurrentHashMap介绍
ConcurrentHashMap原理和数据结构
ConcurrentHashMap函数列表
ConcurrentHashMap源码分析(JDK1.7.0_40版本)
ConcurrentHashMap示例
转载请注明出处：http://www.cnblogs.com/skywang12345/p/3498537.html
ConcurrentHashMap介绍
ConcurrentHashMap是线程安全的哈希表。HashMap, Hashtable, ConcurrentHashMap之间的关联如下：
HashMap是非线程安全的哈希表，常用于单线程程序中。
Hashtable是线程安全的哈希表，它是通过synchronized来保证线程安全的；即，多线程通过同一个“对象的同步锁”来实现并发控制。Hashtable在线程竞争激烈时，效率比较低(此时建议使用ConcurrentHashMap)！因为当一个线程访问Hashtable的同步方法时，其它线程就访问Hashtable的同步方法时，可能会进入阻塞状态。
ConcurrentHashMap是线程安全的哈希表，它是通过“锁分段”来保证线程安全的。ConcurrentHashMap将哈希表分成许多片段(Segment)，每一个片段除了保存哈希表之外，本质上也是一个“可重入的互斥锁”(ReentrantLock)。多线程对同一个片段的访问，是互斥的；但是，对于不同片段的访问，却是可以同步进行的。
关于HashMap,Hashtable以及ReentrantLock的更多内容，可以参考：
1. Java 集合系列10之 HashMap详细介绍(源码解析)和使用示例
2. Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例
3. Java多线程系列--“JUC锁”02之 互斥锁ReentrantLock
ConcurrentHashMap原理和数据结构
要想搞清ConcurrentHashMap，必须先弄清楚它的数据结构：
(01) ConcurrentHashMap继承于AbstractMap抽象类。
(02) Segment是ConcurrentHashMap中的内部类，它就是ConcurrentHashMap中的“锁分段”对应的存储结构。ConcurrentHashMap与Segment是组合关系，1个ConcurrentHashMap对象包含若干个Segment对象。在代码中，这表现为ConcurrentHashMap类中存在“Segment数组”成员。
(03) Segment类继承于ReentrantLock类，所以Segment本质上是一个可重入的互斥锁。
(04) HashEntry也是ConcurrentHashMap的内部类，是单向链表节点，存储着key-value键值对。Segment与HashEntry是组合关系，Segment类中存在“HashEntry数组”成员，“HashEntry数组”中的每个HashEntry就是一个单向链表。
对于多线程访问对一个“哈希表对象”竞争资源，Hashtable是通过一把锁来控制并发；而ConcurrentHashMap则是将哈希表分成许多片段，对于每一个片段分别通过一个互斥锁来控制并发。ConcurrentHashMap对并发的控制更加细腻，它也更加适应于高并发场景！
ConcurrentHashMap函数列表
// 创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。 ConcurrentHashMap() // 创建一个带有指定初始容量、默认加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。 ConcurrentHashMap(int initialCapacity) // 创建一个带有指定初始容量、加载因子和默认 concurrencyLevel (16) 的新的空映射。 ConcurrentHashMap(int initialCapacity, float loadFactor) // 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。 ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) // 构造一个与给定映射具有相同映射关系的新映射。 ConcurrentHashMap(Map<? extends K,? extends V> m) // 从该映射中移除所有映射关系 void clear() // 一种遗留方法，测试此表中是否有一些与指定值存在映射关系的键。 boolean contains(Object value) // 测试指定对象是否为此表中的键。 boolean containsKey(Object key) // 如果此映射将一个或多个键映射到指定值，则返回 true。 boolean containsValue(Object value) // 返回此表中值的枚举。 Enumeration<V> elements() // 返回此映射所包含的映射关系的 Set 视图。 Set<Map.Entry<K,V>> entrySet() // 返回指定键所映射到的值，如果此映射不包含该键的映射关系，则返回 null。 V get(Object key) // 如果此映射不包含键-值映射关系，则返回 true。 boolean isEmpty() // 返回此表中键的枚举。 Enumeration<K> keys() // 返回此映射中包含的键的 Set 视图。 Set<K> keySet() // 将指定键映射到此表中的指定值。 V put(K key, V value) // 将指定映射中所有映射关系复制到此映射中。 void putAll(Map<? extends K,? extends V> m) // 如果指定键已经不再与某个值相关联，则将它与给定值关联。 V putIfAbsent(K key, V value) // 从此映射中移除键（及其相应的值）。 V remove(Object key) // 只有目前将键的条目映射到给定值时，才移除该键的条目。 boolean remove(Object key, Object value) // 只有目前将键的条目映射到某一值时，才替换该键的条目。 V replace(K key, V value) // 只有目前将键的条目映射到给定值时，才替换该键的条目。 boolean replace(K key, V oldValue, V newValue) // 返回此映射中的键-值映射关系数。 int size() // 返回此映射中包含的值的 Collection 视图。 Collection<V> values()
ConcurrentHashMap源码分析(JDK1.7.0_40版本)
ConcurrentHashMap.java的完整源码如下：
1 /* 2 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12 * 13 * 14 * 15 * 16 * 17 * 18 * 19 * 20 * 21 * 22 * 23 */ 24 25 /* 26 * 27 * 28 * 29 * 30 * 31 * Written by Doug Lea with assistance from members of JCP JSR-166 32 * Expert Group and released to the public domain, as explained at 33 * http://creativecommons.org/publicdomain/zero/1.0/ 34 */ 35 36 package java.util.concurrent; 37 import java.util.concurrent.locks.*; 38 import java.util.*; 39 import java.io.Serializable; 40 import java.io.IOException; 41 import java.io.ObjectInputStream; 42 import java.io.ObjectOutputStream; 43 import java.io.ObjectStreamField; 44 45 /** 46 * A hash table supporting full concurrency of retrievals and 47 * adjustable expected concurrency for updates. This class obeys the 48 * same functional specification as {@link java.util.Hashtable}, and 49 * includes versions of methods corresponding to each method of 50 * <tt>Hashtable</tt>. However, even though all operations are 51 * thread-safe, retrieval operations do <em>not</em> entail locking, 52 * and there is <em>not</em> any support for locking the entire table 53 * in a way that prevents all access. This class is fully 54 * interoperable with <tt>Hashtable</tt> in programs that rely on its 55 * thread safety but not on its synchronization details. 56 * 57 * <p> Retrieval operations (including <tt>get</tt>) generally do not 58 * block, so may overlap with update operations (including 59 * <tt>put</tt> and <tt>remove</tt>). Retrievals reflect the results 60 * of the most recently <em>completed</em> update operations holding 61 * upon their onset. For aggregate operations such as <tt>putAll</tt> 62 * and <tt>clear</tt>, concurrent retrievals may reflect insertion or 63 * removal of only some entries. Similarly, Iterators and 64 * Enumerations return elements reflecting the state of the hash table 65 * at some point at or since the creation of the iterator/enumeration. 66 * They do <em>not</em> throw {@link ConcurrentModificationException}. 67 * However, iterators are designed to be used by only one thread at a time. 68 * 69 * <p> The allowed concurrency among update operations is guided by 70 * the optional <tt>concurrencyLevel</tt> constructor argument 71 * (default <tt>16</tt>), which is used as a hint for internal sizing. The 72 * table is internally partitioned to try to permit the indicated 73 * number of concurrent updates without contention. Because placement 74 * in hash tables is essentially random, the actual concurrency will 75 * vary. Ideally, you should choose a value to accommodate as many 76 * threads as will ever concurrently modify the table. Using a 77 * significantly higher value than you need can waste space and time, 78 * and a significantly lower value can lead to thread contention. But 79 * overestimates and underestimates within an order of magnitude do 80 * not usually have much noticeable impact. A value of one is 81 * appropriate when it is known that only one thread will modify and 82 * all others will only read. Also, resizing this or any other kind of 83 * hash table is a relatively slow operation, so, when possible, it is 84 * a good idea to provide estimates of expected table sizes in 85 * constructors. 86 * 87 * <p>This class and its views and iterators implement all of the 88 * <em>optional</em> methods of the {@link Map} and {@link Iterator} 89 * interfaces. 90 * 91 * <p> Like {@link Hashtable} but unlike {@link HashMap}, this class 92 * does <em>not</em> allow <tt>null</tt> to be used as a key or value. 93 * 94 * <p>This class is a member of the 95 * <a href="{@docRoot}/../technotes/guides/collections/index.html"> 96 * Java Collections Framework</a>. 97 * 98 * @since 1.5 99 * @author Doug Lea 100 * @param <K> the type of keys maintained by this map 101 * @param <V> the type of mapped values 102 */ 103 public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> 104 implements ConcurrentMap<K, V>, Serializable { 105 private static final long serialVersionUID = 7249069246763182397L; 106 107 /* 108 * The basic strategy is to subdivide the table among Segments, 109 * each of which itself is a concurrently readable hash table. To 110 * reduce footprint, all but one segments are constructed only 111 * when first needed (see ensureSegment). To maintain visibility 112 * in the presence of lazy construction, accesses to segments as 113 * well as elements of segment's table must use volatile access, 114 * which is done via Unsafe within methods segmentAt etc 115 * below. These provide the functionality of AtomicReferenceArrays 116 * but reduce the levels of indirection. Additionally, 117 * volatile-writes of table elements and entry "next" fields 118 * within locked operations use the cheaper "lazySet" forms of 119 * writes (via putOrderedObject) because these writes are always 120 * followed by lock releases that maintain sequential consistency 121 * of table updates. 122 * 123 * Historical note: The previous version of this class relied 124 * heavily on "final" fields, which avoided some volatile reads at 125 * the expense of a large initial footprint. Some remnants of 126 * that design (including forced construction of segment 0) exist 127 * to ensure serialization compatibility. 128 */ 129 130 /* ---------------- Constants -------------- */ 131 132 /** 133 * The default initial capacity for this table, 134 * used when not otherwise specified in a constructor. 135 */ 136 static final int DEFAULT_INITIAL_CAPACITY = 16; 137 138 /** 139 * The default load factor for this table, used when not 140 * otherwise specified in a constructor. 141 */ 142 static final float DEFAULT_LOAD_FACTOR = 0.75f; 143 144 /** 145 * The default concurrency level for this table, used when not 146 * otherwise specified in a constructor. 147 */ 148 static final int DEFAULT_CONCURRENCY_LEVEL = 16; 149 150 /** 151 * The maximum capacity, used if a higher value is implicitly 152 * specified by either of the constructors with arguments. MUST 153 * be a power of two <= 1<<30 to ensure that entries are indexable 154 * using ints. 155 */ 156 static final int MAXIMUM_CAPACITY = 1 << 30; 157 158 /** 159 * The minimum capacity for per-segment tables. Must be a power 160 * of two, at least two to avoid immediate resizing on next use 161 * after lazy construction. 162 */ 163 static final int MIN_SEGMENT_TABLE_CAPACITY = 2; 164 165 /** 166 * The maximum number of segments to allow; used to bound 167 * constructor arguments. Must be power of two less than 1 << 24. 168 */ 169 static final int MAX_SEGMENTS = 1 << 16; // slightly conservative 170 171 /** 172 * Number of unsynchronized retries in size and containsValue 173 * methods before resorting to locking. This is used to avoid 174 * unbounded retries if tables undergo continuous modification 175 * which would make it impossible to obtain an accurate result. 176 */ 177 static final int RETRIES_BEFORE_LOCK = 2; 178 179 /* ---------------- Fields -------------- */ 180 181 /** 182 * holds values which can't be initialized until after VM is booted. 183 */ 184 private static class Holder { 185 186 /** 187 * Enable alternative hashing of String keys? 188 * 189 * <p>Unlike the other hash map implementations we do not implement a 190 * threshold for regulating whether alternative hashing is used for 191 * String keys. Alternative hashing is either enabled for all instances 192 * or disabled for all instances. 193 */ 194 static final boolean ALTERNATIVE_HASHING; 195 196 static { 197 // Use the "threshold" system property even though our threshold 198 // behaviour is "ON" or "OFF". 199 String altThreshold = java.security.AccessController.doPrivileged( 200 new sun.security.action.GetPropertyAction( 201 "jdk.map.althashing.threshold")); 202 203 int threshold; 204 try { 205 threshold = (null != altThreshold) 206 ? Integer.parseInt(altThreshold) 207 : Integer.MAX_VALUE; 208 209 // disable alternative hashing if -1 210 if (threshold == -1) { 211 threshold = Integer.MAX_VALUE; 212 } 213 214 if (threshold < 0) { 215 throw new IllegalArgumentException("value must be positive integer."); 216 } 217 } catch(IllegalArgumentException failed) { 218 throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed); 219 } 220 ALTERNATIVE_HASHING = threshold <= MAXIMUM_CAPACITY; 221 } 222 } 223 224 /** 225 * A randomizing value associated with this instance that is applied to 226 * hash code of keys to make hash collisions harder to find. 227 */ 228 private transient final int hashSeed = randomHashSeed(this); 229 230 private static int randomHashSeed(ConcurrentHashMap instance) { 231 if (sun.misc.VM.isBooted() && Holder.ALTERNATIVE_HASHING) { 232 return sun.misc.Hashing.randomHashSeed(instance); 233 } 234 235 return 0; 236 } 237 238 /** 239 * Mask value for indexing into segments. The upper bits of a 240 * key's hash code are used to choose the segment. 241 */ 242 final int segmentMask; 243 244 /** 245 * Shift value for indexing within segments. 246 */ 247 final int segmentShift; 248 249 /** 250 * The segments, each of which is a specialized hash table. 251 */ 252 final Segment<K,V>[] segments; 253 254 transient Set<K> keySet; 255 transient Set<Map.Entry<K,V>> entrySet; 256 transient Collection<V> values; 257 258 /** 259 * ConcurrentHashMap list entry. Note that this is never exported 260 * out as a user-visible Map.Entry. 261 */ 262 static final class HashEntry<K,V> { 263 final int hash; 264 final K key; 265 volatile V value; 266 volatile HashEntry<K,V> next; 267 268 HashEntry(int hash, K key, V value, HashEntry<K,V> next) { 269 this.hash = hash; 270 this.key = key; 271 this.value = value; 272 this.next = next; 273 } 274 275 /** 276 * Sets next field with volatile write semantics. (See above 277 * about use of putOrderedObject.) 278 */ 279 final void setNext(HashEntry<K,V> n) { 280 UNSAFE.putOrderedObject(this, nextOffset, n); 281 } 282 283 // Unsafe mechanics 284 static final sun.misc.Unsafe UNSAFE; 285 static final long nextOffset; 286 static { 287 try { 288 UNSAFE = sun.misc.Unsafe.getUnsafe(); 289 Class k = HashEntry.class; 290 nextOffset = UNSAFE.objectFieldOffset 291 (k.getDeclaredField("next")); 292 } catch (Exception e) { 293 throw new Error(e); 294 } 295 } 296 } 297 298 /** 299 * Gets the ith element of given table (if nonnull) with volatile 300 * read semantics. Note: This is manually integrated into a few 301 * performance-sensitive methods to reduce call overhead. 302 */ 303 @SuppressWarnings("unchecked") 304 static final <K,V> HashEntry<K,V> entryAt(HashEntry<K,V>[] tab, int i) { 305 return (tab == null) ? null : 306 (HashEntry<K,V>) UNSAFE.getObjectVolatile 307 (tab, ((long)i << TSHIFT) + TBASE); 308 } 309 310 /** 311 * Sets the ith element of given table, with volatile write 312 * semantics. (See above about use of putOrderedObject.) 313 */ 314 static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i, 315 HashEntry<K,V> e) { 316 UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e); 317 } 318 319 /** 320 * Applies a supplemental hash function to a given hashCode, which 321 * defends against poor quality hash functions. This is critical 322 * because ConcurrentHashMap uses power-of-two length hash tables, 323 * that otherwise encounter collisions for hashCodes that do not 324 * differ in lower or upper bits. 325 */ 326 private int hash(Object k) { 327 int h = hashSeed; 328 329 if ((0 != h) && (k instanceof String)) { 330 return sun.misc.Hashing.stringHash32((String) k); 331 } 332 333 h ^= k.hashCode(); 334 335 // Spread bits to regularize both segment and index locations, 336 // using variant of single-word Wang/Jenkins hash. 337 h += (h << 15) ^ 0xffffcd7d; 338 h ^= (h >>> 10); 339 h += (h << 3); 340 h ^= (h >>> 6); 341 h += (h << 2) + (h << 14); 342 return h ^ (h >>> 16); 343 } 344 345 /** 346 * Segments are specialized versions of hash tables. This 347 * subclasses from ReentrantLock opportunistically, just to 348 * simplify some locking and avoid separate construction. 349 */ 350 static final class Segment<K,V> extends ReentrantLock implements Serializable { 351 /* 352 * Segments maintain a table of entry lists that are always 353 * kept in a consistent state, so can be read (via volatile 354 * reads of segments and tables) without locking. This 355 * requires replicating nodes when necessary during table 356 * resizing, so the old lists can be traversed by readers 357 * still using old version of table. 358 * 359 * This class defines only mutative methods requiring locking. 360 * Except as noted, the methods of this class perform the 361 * per-segment versions of ConcurrentHashMap methods. (Other 362 * methods are integrated directly into ConcurrentHashMap 363 * methods.) These mutative methods use a form of controlled 364 * spinning on contention via methods scanAndLock and 365 * scanAndLockForPut. These intersperse tryLocks with 366 * traversals to locate nodes. The main benefit is to absorb 367 * cache misses (which are very common for hash tables) while 368 * obtaining locks so that traversal is faster once 369 * acquired. We do not actually use the found nodes since they 370 * must be re-acquired under lock anyway to ensure sequential 371 * consistency of updates (and in any case may be undetectably 372 * stale), but they will normally be much faster to re-locate. 373 * Also, scanAndLockForPut speculatively creates a fresh node 374 * to use in put if no node is found. 375 */ 376 377 private static final long serialVersionUID = 2249069246763182397L; 378 379 /** 380 * The maximum number of times to tryLock in a prescan before 381 * possibly blocking on acquire in preparation for a locked 382 * segment operation. On multiprocessors, using a bounded 383 * number of retries maintains cache acquired while locating 384 * nodes. 385 */ 386 static final int MAX_SCAN_RETRIES = 387 Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1; 388 389 /** 390 * The per-segment table. Elements are accessed via 391 * entryAt/setEntryAt providing volatile semantics. 392 */ 393 transient volatile HashEntry<K,V>[] table; 394 395 /** 396 * The number of elements. Accessed only either within locks 397 * or among other volatile reads that maintain visibility. 398 */ 399 transient int count; 400 401 /** 402 * The total number of mutative operations in this segment. 403 * Even though this may overflows 32 bits, it provides 404 * sufficient accuracy for stability checks in CHM isEmpty() 405 * and size() methods. Accessed only either within locks or 406 * among other volatile reads that maintain visibility. 407 */ 408 transient int modCount; 409 410 /** 411 * The table is rehashed when its size exceeds this threshold. 412 * (The value of this field is always <tt>(int)(capacity * 413 * loadFactor)</tt>.) 414 */ 415 transient int threshold; 416 417 /** 418 * The load factor for the hash table. Even though this value 419 * is same for all segments, it is replicated to avoid needing 420 * links to outer object. 421 * @serial 422 */ 423 final float loadFactor; 424 425 Segment(float lf, int threshold, HashEntry<K,V>[] tab) { 426 this.loadFactor = lf; 427 this.threshold = threshold; 428 this.table = tab; 429 } 430 431 final V put(K key, int hash, V value, boolean onlyIfAbsent) { 432 HashEntry<K,V> node = tryLock() ? null : 433 scanAndLockForPut(key, hash, value); 434 V oldValue; 435 try { 436 HashEntry<K,V>[] tab = table; 437 int index = (tab.length - 1) & hash; 438 HashEntry<K,V> first = entryAt(tab, index); 439 for (HashEntry<K,V> e = first;;) { 440 if (e != null) { 441 K k; 442 if ((k = e.key) == key || 443 (e.hash == hash && key.equals(k))) { 444 oldValue = e.value; 445 if (!onlyIfAbsent) { 446 e.value = value; 447 ++modCount; 448 } 449 break; 450 } 451 e = e.next; 452 } 453 else { 454 if (node != null) 455 node.setNext(first); 456 else 457 node = new HashEntry<K,V>(hash, key, value, first); 458 int c = count + 1; 459 if (c > threshold && tab.length < MAXIMUM_CAPACITY) 460 rehash(node); 461 else 462 setEntryAt(tab, index, node); 463 ++modCount; 464 count = c; 465 oldValue = null; 466 break; 467 } 468 } 469 } finally { 470 unlock(); 471 } 472 return oldValue; 473 } 474 475 /** 476 * Doubles size of table and repacks entries, also adding the 477 * given node to new table 478 */ 479 @SuppressWarnings("unchecked") 480 private void rehash(HashEntry<K,V> node) { 481 /* 482 * Reclassify nodes in each list to new table. Because we 483 * are using power-of-two expansion, the elements from 484 * each bin must either stay at same index, or move with a 485 * power of two offset. We eliminate unnecessary node 486 * creation by catching cases where old nodes can be 487 * reused because their next fields won't change. 488 * Statistically, at the default threshold, only about 489 * one-sixth of them need cloning when a table 490 * doubles. The nodes they replace will be garbage 491 * collectable as soon as they are no longer referenced by 492 * any reader thread that may be in the midst of 493 * concurrently traversing table. Entry accesses use plain 494 * array indexing because they are followed by volatile 495 * table write. 496 */ 497 HashEntry<K,V>[] oldTable = table; 498 int oldCapacity = oldTable.length; 499 int newCapacity = oldCapacity << 1; 500 threshold = (int)(newCapacity * loadFactor); 501 HashEntry<K,V>[] newTable = 502 (HashEntry<K,V>[]) new HashEntry[newCapacity]; 503 int sizeMask = newCapacity - 1; 504 for (int i = 0; i < oldCapacity ; i++) { 505 HashEntry<K,V> e = oldTable[i]; 506 if (e != null) { 507 HashEntry<K,V> next = e.next; 508 int idx = e.hash & sizeMask; 509 if (next == null) // Single node on list 510 newTable[idx] = e; 511 else { // Reuse consecutive sequence at same slot 512 HashEntry<K,V> lastRun = e; 513 int lastIdx = idx; 514 for (HashEntry<K,V> last = next; 515 last != null; 516 last = last.next) { 517 int k = last.hash & sizeMask; 518 if (k != lastIdx) { 519 lastIdx = k; 520 lastRun = last; 521 } 522 } 523 newTable[lastIdx] = lastRun; 524 // Clone remaining nodes 525 for (HashEntry<K,V> p = e; p != lastRun; p = p.next) { 526 V v = p.value; 527 int h = p.hash; 528 int k = h & sizeMask; 529 HashEntry<K,V> n = newTable[k]; 530 newTable[k] = new HashEntry<K,V>(h, p.key, v, n); 531 } 532 } 533 } 534 } 535 int nodeIndex = node.hash & sizeMask; // add the new node 536 node.setNext(newTable[nodeIndex]); 537 newTable[nodeIndex] = node; 538 table = newTable; 539 } 540 541 /** 542 * Scans for a node containing given key while trying to 543 * acquire lock, creating and returning one if not found. Upon 544 * return, guarantees that lock is held. UNlike in most 545 * methods, calls to method equals are not screened: Since 546 * traversal speed doesn't matter, we might as well help warm 547 * up the associated code and accesses as well. 548 * 549 * @return a new node if key not found, else null 550 */ 551 private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) { 552 HashEntry<K,V> first = entryForHash(this, hash); 553 HashEntry<K,V> e = first; 554 HashEntry<K,V> node = null; 555 int retries = -1; // negative while locating node 556 while (!tryLock()) { 557 HashEntry<K,V> f; // to recheck first below 558 if (retries < 0) { 559 if (e == null) { 560 if (node == null) // speculatively create node 561 node = new HashEntry<K,V>(hash, key, value, null); 562 retries = 0; 563 } 564 else if (key.equals(e.key)) 565 retries = 0; 566 else 567 e = e.next; 568 } 569 else if (++retries > MAX_SCAN_RETRIES) { 570 lock(); 571 break; 572 } 573 else if ((retries & 1) == 0 && 574 (f = entryForHash(this, hash)) != first) { 575 e = first = f; // re-traverse if entry changed 576 retries = -1; 577 } 578 } 579 return node; 580 } 581 582 /** 583 * Scans for a node containing the given key while trying to 584 * acquire lock for a remove or replace operation. Upon 585 * return, guarantees that lock is held. Note that we must 586 * lock even if the key is not found, to ensure sequential 587 * consistency of updates. 588 */ 589 private void scanAndLock(Object key, int hash) { 590 // similar to but simpler than scanAndLockForPut 591 HashEntry<K,V> first = entryForHash(this, hash); 592 HashEntry<K,V> e = first; 593 int retries = -1; 594 while (!tryLock()) { 595 HashEntry<K,V> f; 596 if (retries < 0) { 597 if (e == null || key.equals(e.key)) 598 retries = 0; 599 else 600 e = e.next; 601 } 602 else if (++retries > MAX_SCAN_RETRIES) { 603 lock(); 604 break; 605 } 606 else if ((retries & 1) == 0 && 607 (f = entryForHash(this, hash)) != first) { 608 e = first = f; 609 retries = -1; 610 } 611 } 612 } 613 614 /** 615 * Remove; match on key only if value null, else match both. 616 */ 617 final V remove(Object key, int hash, Object value) { 618 if (!tryLock()) 619 scanAndLock(key, hash); 620 V oldValue = null; 621 try { 622 HashEntry<K,V>[] tab = table; 623 int index = (tab.length - 1) & hash; 624 HashEntry<K,V> e = entryAt(tab, index); 625 HashEntry<K,V> pred = null; 626 while (e != null) { 627 K k; 628 HashEntry<K,V> next = e.next; 629 if ((k = e.key) == key || 630 (e.hash == hash && key.equals(k))) { 631 V v = e.value; 632 if (value == null || value == v || value.equals(v)) { 633 if (pred == null) 634 setEntryAt(tab, index, next); 635 else 636 pred.setNext(next); 637 ++modCount; 638 --count; 639 oldValue = v; 640 } 641 break; 642 } 643 pred = e; 644 e = next; 645 } 646 } finally { 647 unlock(); 648 } 649 return oldValue; 650 } 651 652 final boolean replace(K key, int hash, V oldValue, V newValue) { 653 if (!tryLock()) 654 scanAndLock(key, hash); 655 boolean replaced = false; 656 try { 657 HashEntry<K,V> e; 658 for (e = entryForHash(this, hash); e != null; e = e.next) { 659 K k; 660 if ((k = e.key) == key || 661 (e.hash == hash && key.equals(k))) { 662 if (oldValue.equals(e.value)) { 663 e.value = newValue; 664 ++modCount; 665 replaced = true; 666 } 667 break; 668 } 669 } 670 } finally { 671 unlock(); 672 } 673 return replaced; 674 } 675 676 final V replace(K key, int hash, V value) { 677 if (!tryLock()) 678 scanAndLock(key, hash); 679 V oldValue = null; 680 try { 681 HashEntry<K,V> e; 682 for (e = entryForHash(this, hash); e != null; e = e.next) { 683 K k; 684 if ((k = e.key) == key || 685 (e.hash == hash && key.equals(k))) { 686 oldValue = e.value; 687 e.value = value; 688 ++modCount; 689 break; 690 } 691 } 692 } finally { 693 unlock(); 694 } 695 return oldValue; 696 } 697 698 final void clear() { 699 lock(); 700 try { 701 HashEntry<K,V>[] tab = table; 702 for (int i = 0; i < tab.length ; i++) 703 setEntryAt(tab, i, null); 704 ++modCount; 705 count = 0; 706 } finally { 707 unlock(); 708 } 709 } 710 } 711 712 // Accessing segments 713 714 /** 715 * Gets the jth element of given segment array (if nonnull) with 716 * volatile element access semantics via Unsafe. (The null check 717 * can trigger harmlessly only during deserialization.) Note: 718 * because each element of segments array is set only once (using 719 * fully ordered writes), some performance-sensitive methods rely 720 * on this method only as a recheck upon null reads. 721 */ 722 @SuppressWarnings("unchecked") 723 static final <K,V> Segment<K,V> segmentAt(Segment<K,V>[] ss, int j) { 724 long u = (j << SSHIFT) + SBASE; 725 return ss == null ? null : 726 (Segment<K,V>) UNSAFE.getObjectVolatile(ss, u); 727 } 728 729 /** 730 * Returns the segment for the given index, creating it and 731 * recording in segment table (via CAS) if not already present. 732 * 733 * @param k the index 734 * @return the segment 735 */ 736 @SuppressWarnings("unchecked") 737 private Segment<K,V> ensureSegment(int k) { 738 final Segment<K,V>[] ss = this.segments; 739 long u = (k << SSHIFT) + SBASE; // raw offset 740 Segment<K,V> seg; 741 if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { 742 Segment<K,V> proto = ss[0]; // use segment 0 as prototype 743 int cap = proto.table.length; 744 float lf = proto.loadFactor; 745 int threshold = (int)(cap * lf); 746 HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap]; 747 if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) 748 == null) { // recheck 749 Segment<K,V> s = new Segment<K,V>(lf, threshold, tab); 750 while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) 751 == null) { 752 if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s)) 753 break; 754 } 755 } 756 } 757 return seg; 758 } 759 760 // Hash-based segment and entry accesses 761 762 /** 763 * Get the segment for the given hash 764 */ 765 @SuppressWarnings("unchecked") 766 private Segment<K,V> segmentForHash(int h) { 767 long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE; 768 return (Segment<K,V>) UNSAFE.getObjectVolatile(segments, u); 769 } 770 771 /** 772 * Gets the table entry for the given segment and hash 773 */ 774 @SuppressWarnings("unchecked") 775 static final <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) { 776 HashEntry<K,V>[] tab; 777 return (seg == null || (tab = seg.table) == null) ? null : 778 (HashEntry<K,V>) UNSAFE.getObjectVolatile 779 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE); 780 } 781 782 /* ---------------- Public operations -------------- */ 783 784 /** 785 * Creates a new, empty map with the specified initial 786 * capacity, load factor and concurrency level. 787 * 788 * @param initialCapacity the initial capacity. The implementation 789 * performs internal sizing to accommodate this many elements. 790 * @param loadFactor the load factor threshold, used to control resizing. 791 * Resizing may be performed when the average number of elements per 792 * bin exceeds this threshold. 793 * @param concurrencyLevel the estimated number of concurrently 794 * updating threads. The implementation performs internal sizing 795 * to try to accommodate this many threads. 796 * @throws IllegalArgumentException if the initial capacity is 797 * negative or the load factor or concurrencyLevel are 798 * nonpositive. 799 */ 800 @SuppressWarnings("unchecked") 801 public ConcurrentHashMap(int initialCapacity, 802 float loadFactor, int concurrencyLevel) { 803 if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) 804 throw new IllegalArgumentException(); 805 if (concurrencyLevel > MAX_SEGMENTS) 806 concurrencyLevel = MAX_SEGMENTS; 807 // Find power-of-two sizes best matching arguments 808 int sshift = 0; 809 int ssize = 1; 810 while (ssize < concurrencyLevel) { 811 ++sshift; 812 ssize <<= 1; 813 } 814 this.segmentShift = 32 - sshift; 815 this.segmentMask = ssize - 1; 816 if (initialCapacity > MAXIMUM_CAPACITY) 817 initialCapacity = MAXIMUM_CAPACITY; 818 int c = initialCapacity / ssize; 819 if (c * ssize < initialCapacity) 820 ++c; 821 int cap = MIN_SEGMENT_TABLE_CAPACITY; 822 while (cap < c) 823 cap <<= 1; 824 // create segments and segments[0] 825 Segment<K,V> s0 = 826 new Segment<K,V>(loadFactor, (int)(cap * loadFactor), 827 (HashEntry<K,V>[])new HashEntry[cap]); 828 Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize]; 829 UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0] 830 this.segments = ss; 831 } 832 833 /** 834 * Creates a new, empty map with the specified initial capacity 835 * and load factor and with the default concurrencyLevel (16). 836 * 837 * @param initialCapacity The implementation performs internal 838 * sizing to accommodate this many elements. 839 * @param loadFactor the load factor threshold, used to control resizing. 840 * Resizing may be performed when the average number of elements per 841 * bin exceeds this threshold. 842 * @throws IllegalArgumentException if the initial capacity of 843 * elements is negative or the load factor is nonpositive 844 * 845 * @since 1.6 846 */ 847 public ConcurrentHashMap(int initialCapacity, float loadFactor) { 848 this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL); 849 } 850 851 /** 852 * Creates a new, empty map with the specified initial capacity, 853 * and with default load factor (0.75) and concurrencyLevel (16). 854 * 855 * @param initialCapacity the initial capacity. The implementation 856 * performs internal sizing to accommodate this many elements. 857 * @throws IllegalArgumentException if the initial capacity of 858 * elements is negative. 859 */ 860 public ConcurrentHashMap(int initialCapacity) { 861 this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); 862 } 863 864 /** 865 * Creates a new, empty map with a default initial capacity (16), 866 * load factor (0.75) and concurrencyLevel (16). 867 */ 868 public ConcurrentHashMap() { 869 this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); 870 } 871 872 /** 873 * Creates a new map with the same mappings as the given map. 874 * The map is created with a capacity of 1.5 times the number 875 * of mappings in the given map or 16 (whichever is greater), 876 * and a default load factor (0.75) and concurrencyLevel (16). 877 * 878 * @param m the map 879 */ 880 public ConcurrentHashMap(Map<? extends K, ? extends V> m) { 881 this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, 882 DEFAULT_INITIAL_CAPACITY), 883 DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); 884 putAll(m); 885 } 886 887 /** 888 * Returns <tt>true</tt> if this map contains no key-value mappings. 889 * 890 * @return <tt>true</tt> if this map contains no key-value mappings 891 */ 892 public boolean isEmpty() { 893 /* 894 * Sum per-segment modCounts to avoid mis-reporting when 895 * elements are concurrently added and removed in one segment 896 * while checking another, in which case the table was never 897 * actually empty at any point. (The sum ensures accuracy up 898 * through at least 1<<31 per-segment modifications before 899 * recheck.) Methods size() and containsValue() use similar 900 * constructions for stability checks. 901 */ 902 long sum = 0L; 903 final Segment<K,V>[] segments = this.segments; 904 for (int j = 0; j < segments.length; ++j) { 905 Segment<K,V> seg = segmentAt(segments, j); 906 if (seg != null) { 907 if (seg.count != 0) 908 return false; 909 sum += seg.modCount; 910 } 911 } 912 if (sum != 0L) { // recheck unless no modifications 913 for (int j = 0; j < segments.length; ++j) { 914 Segment<K,V> seg = segmentAt(segments, j); 915 if (seg != null) { 916 if (seg.count != 0) 917 return false; 918 sum -= seg.modCount; 919 } 920 } 921 if (sum != 0L) 922 return false; 923 } 924 return true; 925 } 926 927 /** 928 * Returns the number of key-value mappings in this map. If the 929 * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns 930 * <tt>Integer.MAX_VALUE</tt>. 931 * 932 * @return the number of key-value mappings in this map 933 */ 934 public int size() { 935 // Try a few times to get accurate count. On failure due to 936 // continuous async changes in table, resort to locking. 937 final Segment<K,V>[] segments = this.segments; 938 int size; 939 boolean overflow; // true if size overflows 32 bits 940 long sum; // sum of modCounts 941 long last = 0L; // previous sum 942 int retries = -1; // first iteration isn't retry 943 try { 944 for (;;) { 945 if (retries++ == RETRIES_BEFORE_LOCK) { 946 for (int j = 0; j < segments.length; ++j) 947 ensureSegment(j).lock(); // force creation 948 } 949 sum = 0L; 950 size = 0; 951 overflow = false; 952 for (int j = 0; j < segments.length; ++j) { 953 Segment<K,V> seg = segmentAt(segments, j); 954 if (seg != null) { 955 sum += seg.modCount; 956 int c = seg.count; 957 if (c < 0 || (size += c) < 0) 958 overflow = true; 959 } 960 } 961 if (sum == last) 962 break; 963 last = sum; 964 } 965 } finally { 966 if (retries > RETRIES_BEFORE_LOCK) { 967 for (int j = 0; j < segments.length; ++j) 968 segmentAt(segments, j).unlock(); 969 } 970 } 971 return overflow ? Integer.MAX_VALUE : size; 972 } 973 974 /** 975 * Returns the value to which the specified key is mapped, 976 * or {@code null} if this map contains no mapping for the key. 977 * 978 * <p>More formally, if this map contains a mapping from a key 979 * {@code k} to a value {@code v} such that {@code key.equals(k)}, 980 * then this method returns {@code v}; otherwise it returns 981 * {@code null}. (There can be at most one such mapping.) 982 * 983 * @throws NullPointerException if the specified key is null 984 */ 985 public V get(Object key) { 986 Segment<K,V> s; // manually integrate access methods to reduce overhead 987 HashEntry<K,V>[] tab; 988 int h = hash(key); 989 long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE; 990 if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null && 991 (tab = s.table) != null) { 992 for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile 993 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE); 994 e != null; e = e.next) { 995 K k; 996 if ((k = e.key) == key || (e.hash == h && key.equals(k))) 997 return e.value; 998 } 999 } 1000 return null; 1001 } 1002 1003 /** 1004 * Tests if the specified object is a key in this table. 1005 * 1006 * @param key possible key 1007 * @return <tt>true</tt> if and only if the specified object 1008 * is a key in this table, as determined by the 1009 * <tt>equals</tt> method; <tt>false</tt> otherwise. 1010 * @throws NullPointerException if the specified key is null 1011 */ 1012 @SuppressWarnings("unchecked") 1013 public boolean containsKey(Object key) { 1014 Segment<K,V> s; // same as get() except no need for volatile value read 1015 HashEntry<K,V>[] tab; 1016 int h = hash(key); 1017 long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE; 1018 if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null && 1019 (tab = s.table) != null) { 1020 for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile 1021 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE); 1022 e != null; e = e.next) { 1023 K k; 1024 if ((k = e.key) == key || (e.hash == h && key.equals(k))) 1025 return true; 1026 } 1027 } 1028 return false; 1029 } 1030 1031 /** 1032 * Returns <tt>true</tt> if this map maps one or more keys to the 1033 * specified value. Note: This method requires a full internal 1034 * traversal of the hash table, and so is much slower than 1035 * method <tt>containsKey</tt>. 1036 * 1037 * @param value value whose presence in this map is to be tested 1038 * @return <tt>true</tt> if this map maps one or more keys to the 1039 * specified value 1040 * @throws NullPointerException if the specified value is null 1041 */ 1042 public boolean containsValue(Object value) { 1043 // Same idea as size() 1044 if (value == null) 1045 throw new NullPointerException(); 1046 final Segment<K,V>[] segments = this.segments; 1047 boolean found = false; 1048 long last = 0; 1049 int retries = -1; 1050 try { 1051 outer: for (;;) { 1052 if (retries++ == RETRIES_BEFORE_LOCK) { 1053 for (int j = 0; j < segments.length; ++j) 1054 ensureSegment(j).lock(); // force creation 1055 } 1056 long hashSum = 0L; 1057 int sum = 0; 1058 for (int j = 0; j < segments.length; ++j) { 1059 HashEntry<K,V>[] tab; 1060 Segment<K,V> seg = segmentAt(segments, j); 1061 if (seg != null && (tab = seg.table) != null) { 1062 for (int i = 0 ; i < tab.length; i++) { 1063 HashEntry<K,V> e; 1064 for (e = entryAt(tab, i); e != null; e = e.next) { 1065 V v = e.value; 1066 if (v != null && value.equals(v)) { 1067 found = true; 1068 break outer; 1069 } 1070 } 1071 } 1072 sum += seg.modCount; 1073 } 1074 } 1075 if (retries > 0 && sum == last) 1076 break; 1077 last = sum; 1078 } 1079 } finally { 1080 if (retries > RETRIES_BEFORE_LOCK) { 1081 for (int j = 0; j < segments.length; ++j) 1082 segmentAt(segments, j).unlock(); 1083 } 1084 } 1085 return found; 1086 } 1087 1088 /** 1089 * Legacy method testing if some key maps into the specified value 1090 * in this table. This method is identical in functionality to 1091 * {@link #containsValue}, and exists solely to ensure 1092 * full compatibility with class {@link java.util.Hashtable}, 1093 * which supported this method prior to introduction of the 1094 * Java Collections framework. 1095 1096 * @param value a value to search for 1097 * @return <tt>true</tt> if and only if some key maps to the 1098 * <tt>value</tt> argument in this table as 1099 * determined by the <tt>equals</tt> method; 1100 * <tt>false</tt> otherwise 1101 * @throws NullPointerException if the specified value is null 1102 */ 1103 public boolean contains(Object value) { 1104 return containsValue(value); 1105 } 1106 1107 /** 1108 * Maps the specified key to the specified value in this table. 1109 * Neither the key nor the value can be null. 1110 * 1111 * <p> The value can be retrieved by calling the <tt>get</tt> method 1112 * with a key that is equal to the original key. 1113 * 1114 * @param key key with which the specified value is to be associated 1115 * @param value value to be associated with the specified key 1116 * @return the previous value associated with <tt>key</tt>, or 1117 * <tt>null</tt> if there was no mapping for <tt>key</tt> 1118 * @throws NullPointerException if the specified key or value is null 1119 */ 1120 @SuppressWarnings("unchecked") 1121 public V put(K key, V value) { 1122 Segment<K,V> s; 1123 if (value == null) 1124 throw new NullPointerException(); 1125 int hash = hash(key); 1126 int j = (hash >>> segmentShift) & segmentMask; 1127 if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck 1128 (segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment 1129 s = ensureSegment(j); 1130 return s.put(key, hash, value, false); 1131 } 1132 1133 /** 1134 * {@inheritDoc} 1135 * 1136 * @return the previous value associated with the specified key, 1137 * or <tt>null</tt> if there was no mapping for the key 1138 * @throws NullPointerException if the specified key or value is null 1139 */ 1140 @SuppressWarnings("unchecked") 1141 public V putIfAbsent(K key, V value) { 1142 Segment<K,V> s; 1143 if (value == null) 1144 throw new NullPointerException(); 1145 int hash = hash(key); 1146 int j = (hash >>> segmentShift) & segmentMask; 1147 if ((s = (Segment<K,V>)UNSAFE.getObject 1148 (segments, (j << SSHIFT) + SBASE)) == null) 1149 s = ensureSegment(j); 1150 return s.put(key, hash, value, true); 1151 } 1152 1153 /** 1154 * Copies all of the mappings from the specified map to this one. 1155 * These mappings replace any mappings that this map had for any of the 1156 * keys currently in the specified map. 1157 * 1158 * @param m mappings to be stored in this map 1159 */ 1160 public void putAll(Map<? extends K, ? extends V> m) { 1161 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) 1162 put(e.getKey(), e.getValue()); 1163 } 1164 1165 /** 1166 * Removes the key (and its corresponding value) from this map. 1167 * This method does nothing if the key is not in the map. 1168 * 1169 * @param key the key that needs to be removed 1170 * @return the previous value associated with <tt>key</tt>, or 1171 * <tt>null</tt> if there was no mapping for <tt>key</tt> 1172 * @throws NullPointerException if the specified key is null 1173 */ 1174 public V remove(Object key) { 1175 int hash = hash(key); 1176 Segment<K,V> s = segmentForHash(hash); 1177 return s == null ? null : s.remove(key, hash, null); 1178 } 1179 1180 /** 1181 * {@inheritDoc} 1182 * 1183 * @throws NullPointerException if the specified key is null 1184 */ 1185 public boolean remove(Object key, Object value) { 1186 int hash = hash(key); 1187 Segment<K,V> s; 1188 return value != null && (s = segmentForHash(hash)) != null && 1189 s.remove(key, hash, value) != null; 1190 } 1191 1192 /** 1193 * {@inheritDoc} 1194 * 1195 * @throws NullPointerException if any of the arguments are null 1196 */ 1197 public boolean replace(K key, V oldValue, V newValue) { 1198 int hash = hash(key); 1199 if (oldValue == null || newValue == null) 1200 throw new NullPointerException(); 1201 Segment<K,V> s = segmentForHash(hash); 1202 return s != null && s.replace(key, hash, oldValue, newValue); 1203 } 1204 1205 /** 1206 * {@inheritDoc} 1207 * 1208 * @return the previous value associated with the specified key, 1209 * or <tt>null</tt> if there was no mapping for the key 1210 * @throws NullPointerException if the specified key or value is null 1211 */ 1212 public V replace(K key, V value) { 1213 int hash = hash(key); 1214 if (value == null) 1215 throw new NullPointerException(); 1216 Segment<K,V> s = segmentForHash(hash); 1217 return s == null ? null : s.replace(key, hash, value); 1218 } 1219 1220 /** 1221 * Removes all of the mappings from this map. 1222 */ 1223 public void clear() { 1224 final Segment<K,V>[] segments = this.segments; 1225 for (int j = 0; j < segments.length; ++j) { 1226 Segment<K,V> s = segmentAt(segments, j); 1227 if (s != null) 1228 s.clear(); 1229 } 1230 } 1231 1232 /** 1233 * Returns a {@link Set} view of the keys contained in this map. 1234 * The set is backed by the map, so changes to the map are 1235 * reflected in the set, and vice-versa. The set supports element 1236 * removal, which removes the corresponding mapping from this map, 1237 * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, 1238 * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> 1239 * operations. It does not support the <tt>add</tt> or 1240 * <tt>addAll</tt> operations. 1241 * 1242 * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator 1243 * that will never throw {@link ConcurrentModificationException}, 1244 * and guarantees to traverse elements as they existed upon 1245 * construction of the iterator, and may (but is not guaranteed to) 1246 * reflect any modifications subsequent to construction. 1247 */ 1248 public Set<K> keySet() { 1249 Set<K> ks = keySet; 1250 return (ks != null) ? ks : (keySet = new KeySet()); 1251 } 1252 1253 /** 1254 * Returns a {@link Collection} view of the values contained in this map. 1255 * The collection is backed by the map, so changes to the map are 1256 * reflected in the collection, and vice-versa. The collection 1257 * supports element removal, which removes the corresponding 1258 * mapping from this map, via the <tt>Iterator.remove</tt>, 1259 * <tt>Collection.remove</tt>, <tt>removeAll</tt>, 1260 * <tt>retainAll</tt>, and <tt>clear</tt> operations. It does not 1261 * support the <tt>add</tt> or <tt>addAll</tt> operations. 1262 * 1263 * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator 1264 * that will never throw {@link ConcurrentModificationException}, 1265 * and guarantees to traverse elements as they existed upon 1266 * construction of the iterator, and may (but is not guaranteed to) 1267 * reflect any modifications subsequent to construction. 1268 */ 1269 public Collection<V> values() { 1270 Collection<V> vs = values; 1271 return (vs != null) ? vs : (values = new Values()); 1272 } 1273 1274 /** 1275 * Returns a {@link Set} view of the mappings contained in this map. 1276 * The set is backed by the map, so changes to the map are 1277 * reflected in the set, and vice-versa. The set supports element 1278 * removal, which removes the corresponding mapping from the map, 1279 * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, 1280 * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> 1281 * operations. It does not support the <tt>add</tt> or 1282 * <tt>addAll</tt> operations. 1283 * 1284 * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator 1285 * that will never throw {@link ConcurrentModificationException}, 1286 * and guarantees to traverse elements as they existed upon 1287 * construction of the iterator, and may (but is not guaranteed to) 1288 * reflect any modifications subsequent to construction. 1289 */ 1290 public Set<Map.Entry<K,V>> entrySet() { 1291 Set<Map.Entry<K,V>> es = entrySet; 1292 return (es != null) ? es : (entrySet = new EntrySet()); 1293 } 1294 1295 /** 1296 * Returns an enumeration of the keys in this table. 1297 * 1298 * @return an enumeration of the keys in this table 1299 * @see #keySet() 1300 */ 1301 public Enumeration<K> keys() { 1302 return new KeyIterator(); 1303 } 1304 1305 /** 1306 * Returns an enumeration of the values in this table. 1307 * 1308 * @return an enumeration of the values in this table 1309 * @see #values() 1310 */ 1311 public Enumeration<V> elements() { 1312 return new ValueIterator(); 1313 } 1314 1315 /* ---------------- Iterator Support -------------- */ 1316 1317 abstract class HashIterator { 1318 int nextSegmentIndex; 1319 int nextTableIndex; 1320 HashEntry<K,V>[] currentTable; 1321 HashEntry<K, V> nextEntry; 1322 HashEntry<K, V> lastReturned; 1323 1324 HashIterator() { 1325 nextSegmentIndex = segments.length - 1; 1326 nextTableIndex = -1; 1327 advance(); 1328 } 1329 1330 /** 1331 * Set nextEntry to first node of next non-empty table 1332 * (in backwards order, to simplify checks). 1333 */ 1334 final void advance() { 1335 for (;;) { 1336 if (nextTableIndex >= 0) { 1337 if ((nextEntry = entryAt(currentTable, 1338 nextTableIndex--)) != null) 1339 break; 1340 } 1341 else if (nextSegmentIndex >= 0) { 1342 Segment<K,V> seg = segmentAt(segments, nextSegmentIndex--); 1343 if (seg != null && (currentTable = seg.table) != null) 1344 nextTableIndex = currentTable.length - 1; 1345 } 1346 else 1347 break; 1348 } 1349 } 1350 1351 final HashEntry<K,V> nextEntry() { 1352 HashEntry<K,V> e = nextEntry; 1353 if (e == null) 1354 throw new NoSuchElementException(); 1355 lastReturned = e; // cannot assign until after null check 1356 if ((nextEntry = e.next) == null) 1357 advance(); 1358 return e; 1359 } 1360 1361 public final boolean hasNext() { return nextEntry != null; } 1362 public final boolean hasMoreElements() { return nextEntry != null; } 1363 1364 public final void remove() { 1365 if (lastReturned == null) 1366 throw new IllegalStateException(); 1367 ConcurrentHashMap.this.remove(lastReturned.key); 1368 lastReturned = null; 1369 } 1370 } 1371 1372 final class KeyIterator 1373 extends HashIterator 1374 implements Iterator<K>, Enumeration<K> 1375 { 1376 public final K next() { return super.nextEntry().key; } 1377 public final K nextElement() { return super.nextEntry().key; } 1378 } 1379 1380 final class ValueIterator 1381 extends HashIterator 1382 implements Iterator<V>, Enumeration<V> 1383 { 1384 public final V next() { return super.nextEntry().value; } 1385 public final V nextElement() { return super.nextEntry().value; } 1386 } 1387 1388 /** 1389 * Custom Entry class used by EntryIterator.next(), that relays 1390 * setValue changes to the underlying map. 1391 */ 1392 final class WriteThroughEntry 1393 extends AbstractMap.SimpleEntry<K,V> 1394 { 1395 WriteThroughEntry(K k, V v) { 1396 super(k,v); 1397 } 1398 1399 /** 1400 * Set our entry's value and write through to the map. The 1401 * value to return is somewhat arbitrary here. Since a 1402 * WriteThroughEntry does not necessarily track asynchronous 1403 * changes, the most recent "previous" value could be 1404 * different from what we return (or could even have been 1405 * removed in which case the put will re-establish). We do not 1406 * and cannot guarantee more. 1407 */ 1408 public V setValue(V value) { 1409 if (value == null) throw new NullPointerException(); 1410 V v = super.setValue(value); 1411 ConcurrentHashMap.this.put(getKey(), value); 1412 return v; 1413 } 1414 } 1415 1416 final class EntryIterator 1417 extends HashIterator 1418 implements Iterator<Entry<K,V>> 1419 { 1420 public Map.Entry<K,V> next() { 1421 HashEntry<K,V> e = super.nextEntry(); 1422 return new WriteThroughEntry(e.key, e.value); 1423 } 1424 } 1425 1426 final class KeySet extends AbstractSet<K> { 1427 public Iterator<K> iterator() { 1428 return new KeyIterator(); 1429 } 1430 public int size() { 1431 return ConcurrentHashMap.this.size(); 1432 } 1433 public boolean isEmpty() { 1434 return ConcurrentHashMap.this.isEmpty(); 1435 } 1436 public boolean contains(Object o) { 1437 return ConcurrentHashMap.this.containsKey(o); 1438 } 1439 public boolean remove(Object o) { 1440 return ConcurrentHashMap.this.remove(o) != null; 1441 } 1442 public void clear() { 1443 ConcurrentHashMap.this.clear(); 1444 } 1445 } 1446 1447 final class Values extends AbstractCollection<V> { 1448 public Iterator<V> iterator() { 1449 return new ValueIterator(); 1450 } 1451 public int size() { 1452 return ConcurrentHashMap.this.size(); 1453 } 1454 public boolean isEmpty() { 1455 return ConcurrentHashMap.this.isEmpty(); 1456 } 1457 public boolean contains(Object o) { 1458 return ConcurrentHashMap.this.containsValue(o); 1459 } 1460 public void clear() { 1461 ConcurrentHashMap.this.clear(); 1462 } 1463 } 1464 1465 final class EntrySet extends AbstractSet<Map.Entry<K,V>> { 1466 public Iterator<Map.Entry<K,V>> iterator() { 1467 return new EntryIterator(); 1468 } 1469 public boolean contains(Object o) { 1470 if (!(o instanceof Map.Entry)) 1471 return false; 1472 Map.Entry<?,?> e = (Map.Entry<?,?>)o; 1473 V v = ConcurrentHashMap.this.get(e.getKey()); 1474 return v != null && v.equals(e.getValue()); 1475 } 1476 public boolean remove(Object o) { 1477 if (!(o instanceof Map.Entry)) 1478 return false; 1479 Map.Entry<?,?> e = (Map.Entry<?,?>)o; 1480 return ConcurrentHashMap.this.remove(e.getKey(), e.getValue()); 1481 } 1482 public int size() { 1483 return ConcurrentHashMap.this.size(); 1484 } 1485 public boolean isEmpty() { 1486 return ConcurrentHashMap.this.isEmpty(); 1487 } 1488 public void clear() { 1489 ConcurrentHashMap.this.clear(); 1490 } 1491 } 1492 1493 /* ---------------- Serialization Support -------------- */ 1494 1495 /** 1496 * Save the state of the <tt>ConcurrentHashMap</tt> instance to a 1497 * stream (i.e., serialize it). 1498 * @param s the stream 1499 * @serialData 1500 * the key (Object) and value (Object) 1501 * for each key-value mapping, followed by a null pair. 1502 * The key-value mappings are emitted in no particular order. 1503 */ 1504 private void writeObject(java.io.ObjectOutputStream s) throws IOException { 1505 // force all segments for serialization compatibility 1506 for (int k = 0; k < segments.length; ++k) 1507 ensureSegment(k); 1508 s.defaultWriteObject(); 1509 1510 final Segment<K,V>[] segments = this.segments; 1511 for (int k = 0; k < segments.length; ++k) { 1512 Segment<K,V> seg = segmentAt(segments, k); 1513 seg.lock(); 1514 try { 1515 HashEntry<K,V>[] tab = seg.table; 1516 for (int i = 0; i < tab.length; ++i) { 1517 HashEntry<K,V> e; 1518 for (e = entryAt(tab, i); e != null; e = e.next) { 1519 s.writeObject(e.key); 1520 s.writeObject(e.value); 1521 } 1522 } 1523 } finally { 1524 seg.unlock(); 1525 } 1526 } 1527 s.writeObject(null); 1528 s.writeObject(null); 1529 } 1530 1531 /** 1532 * Reconstitute the <tt>ConcurrentHashMap</tt> instance from a 1533 * stream (i.e., deserialize it). 1534 * @param s the stream 1535 */ 1536 @SuppressWarnings("unchecked") 1537 private void readObject(java.io.ObjectInputStream s) 1538 throws IOException, ClassNotFoundException { 1539 // Don't call defaultReadObject() 1540 ObjectInputStream.GetField oisFields = s.readFields(); 1541 final Segment<K,V>[] oisSegments = (Segment<K,V>[])oisFields.get("segments", null); 1542 1543 final int ssize = oisSegments.length; 1544 if (ssize < 1 || ssize > MAX_SEGMENTS 1545 || (ssize & (ssize-1)) != 0 ) // ssize not power of two 1546 throw new java.io.InvalidObjectException("Bad number of segments:" 1547 + ssize); 1548 int sshift = 0, ssizeTmp = ssize; 1549 while (ssizeTmp > 1) { 1550 ++sshift; 1551 ssizeTmp >>>= 1; 1552 } 1553 UNSAFE.putIntVolatile(this, SEGSHIFT_OFFSET, 32 - sshift); 1554 UNSAFE.putIntVolatile(this, SEGMASK_OFFSET, ssize - 1); 1555 UNSAFE.putObjectVolatile(this, SEGMENTS_OFFSET, oisSegments); 1556 1557 // set hashMask 1558 UNSAFE.putIntVolatile(this, HASHSEED_OFFSET, randomHashSeed(this)); 1559 1560 // Re-initialize segments to be minimally sized, and let grow. 1561 int cap = MIN_SEGMENT_TABLE_CAPACITY; 1562 final Segment<K,V>[] segments = this.segments; 1563 for (int k = 0; k < segments.length; ++k) { 1564 Segment<K,V> seg = segments[k]; 1565 if (seg != null) { 1566 seg.threshold = (int)(cap * seg.loadFactor); 1567 seg.table = (HashEntry<K,V>[]) new HashEntry[cap]; 1568 } 1569 } 1570 1571 // Read the keys and values, and put the mappings in the table 1572 for (;;) { 1573 K key = (K) s.readObject(); 1574 V value = (V) s.readObject(); 1575 if (key == null) 1576 break; 1577 put(key, value); 1578 } 1579 } 1580 1581 // Unsafe mechanics 1582 private static final sun.misc.Unsafe UNSAFE; 1583 private static final long SBASE; 1584 private static final int SSHIFT; 1585 private static final long TBASE; 1586 private static final int TSHIFT; 1587 private static final long HASHSEED_OFFSET; 1588 private static final long SEGSHIFT_OFFSET; 1589 private static final long SEGMASK_OFFSET; 1590 private static final long SEGMENTS_OFFSET; 1591 1592 static { 1593 int ss, ts; 1594 try { 1595 UNSAFE = sun.misc.Unsafe.getUnsafe(); 1596 Class tc = HashEntry[].class; 1597 Class sc = Segment[].class; 1598 TBASE = UNSAFE.arrayBaseOffset(tc); 1599 SBASE = UNSAFE.arrayBaseOffset(sc); 1600 ts = UNSAFE.arrayIndexScale(tc); 1601 ss = UNSAFE.arrayIndexScale(sc); 1602 HASHSEED_OFFSET = UNSAFE.objectFieldOffset( 1603 ConcurrentHashMap.class.getDeclaredField("hashSeed")); 1604 SEGSHIFT_OFFSET = UNSAFE.objectFieldOffset( 1605 ConcurrentHashMap.class.getDeclaredField("segmentShift")); 1606 SEGMASK_OFFSET = UNSAFE.objectFieldOffset( 1607 ConcurrentHashMap.class.getDeclaredField("segmentMask")); 1608 SEGMENTS_OFFSET = UNSAFE.objectFieldOffset( 1609 ConcurrentHashMap.class.getDeclaredField("segments")); 1610 } catch (Exception e) { 1611 throw new Error(e); 1612 } 1613 if ((ss & (ss-1)) != 0 || (ts & (ts-1)) != 0) 1614 throw new Error("data type scale not a power of two"); 1615 SSHIFT = 31 - Integer.numberOfLeadingZeros(ss); 1616 TSHIFT = 31 - Integer.numberOfLeadingZeros(ts); 1617 } 1618 1619 }
下面从ConcurrentHashMap的创建，获取，添加，删除这4个方面对ConcurrentHashMap进行分析。
1 创建
下面以ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel)来进行说明。
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
// 参数有效性判断
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// concurrencyLevel是“用来计算segments的容量”
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
int sshift = 0;
int ssize = 1;
// ssize=“大于或等于concurrencyLevel的最小的2的N次方值”
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
// 初始化segmentShift和segmentMask
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
// 哈希表的初始容量
// 哈希表的实际容量=“segments的容量” x “segments中数组的长度”
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// “哈希表的初始容量” / “segments的容量”
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
// cap就是“segments中的HashEntry数组的长度”
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// segments
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
说明：
(01) 前面我们说过，ConcurrentHashMap采用了“锁分段”技术；在代码中，它通过“segments数组”对象来保存各个分段。segments的定义如下：
final Segment<K,V>[] segments;
concurrencyLevel的作用就是用来计算segments数组的容量大小。先计算出“大于或等于concurrencyLevel的最小的2的N次方值”，然后将其保存为“segments的容量大小(ssize)”。
(02) initialCapacity是哈希表的初始容量。需要注意的是，哈希表的实际容量=“segments的容量” x “segments中数组的长度”。
(03) loadFactor是加载因子。它是哈希表在其容量自动增加之前可以达到多满的一种尺度。
ConcurrentHashMap的构造函数中涉及到的非常重要的一个结构体，它就是Segment。下面看看Segment的声明：
static final class Segment<K,V> extends ReentrantLock implements Serializable { ... transient volatile HashEntry<K,V>[] table; // threshold阈，是哈希表在其容量自动增加之前可以达到多满的一种尺度。 transient int threshold; // loadFactor是加载因子 final float loadFactor; Segment(float lf, int threshold, HashEntry<K,V>[] tab) { this.loadFactor = lf; this.threshold = threshold; this.table = tab; } ... }
说明：Segment包含HashEntry数组，HashEntry保存了哈希表中的键值对。
此外，还需要说明的Segment继承于ReentrantLock。这意味着，Segment本质上就是可重入的互斥锁。
HashEntry的源码如下：
static final class HashEntry<K,V> { final int hash; // 哈希值 final K key; // 键 volatile V value; // 值 volatile HashEntry<K,V> next; // 下一个HashEntry节点 HashEntry(int hash, K key, V value, HashEntry<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } ... }
说明：和HashMap的节点一样，HashEntry也是链表。这就说明，ConcurrentHashMap是链式哈希表，它是通过“拉链法”来解决哈希冲突的。
2 获取
下面以get(Object key)为例，对ConcurrentHashMap的获取方法进行说明。
public V get(Object key) { Segment<K,V> s; // manually integrate access methods to reduce overhead HashEntry<K,V>[] tab; int h = hash(key); long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE; // 获取key对应的Segment片段。 // 如果Segment片段不为null，则在“Segment片段的HashEntry数组中”中找到key所对应的HashEntry列表； // 接着遍历该HashEntry链表，找到于key-value键值对对应的HashEntry节点。 if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null && (tab = s.table) != null) { for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE); e != null; e = e.next) { K k; if ((k = e.key) == key || (e.hash == h && key.equals(k))) return e.value; } } return null; }
说明：get(Object key)的作用是返回key在ConcurrentHashMap哈希表中对应的值。
它首先根据key计算出来的哈希值，获取key所对应的Segment片段。
如果Segment片段不为null，则在“Segment片段的HashEntry数组中”中找到key所对应的HashEntry列表。Segment包含“HashEntry数组”对象，而每一个HashEntry本质上是一个单向链表。
接着遍历该HashEntry链表，找到于key-value键值对对应的HashEntry节点。
下面是hash()的源码
private int hash(Object k) { int h = hashSeed; if ((0 != h) && (k instanceof String)) { return sun.misc.Hashing.stringHash32((String) k); } h ^= k.hashCode(); // Spread bits to regularize both segment and index locations, // using variant of single-word Wang/Jenkins hash. h += (h << 15) ^ 0xffffcd7d; h ^= (h >>> 10); h += (h << 3); h ^= (h >>> 6); h += (h << 2) + (h << 14); return h ^ (h >>> 16); }
3 增加
下面以put(K key, V value)来对ConcurrentHashMap中增加键值对来进行说明。
public V put(K key, V value) { Segment<K,V> s; if (value == null) throw new NullPointerException(); // 获取key对应的哈希值 int hash = hash(key); int j = (hash >>> segmentShift) & segmentMask; // 如果找不到该Segment，则新建一个。 if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck (segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment s = ensureSegment(j); return s.put(key, hash, value, false); }
说明：
(01) put()根据key获取对应的哈希值，再根据哈希值找到对应的Segment片段。如果Segment片段不存在，则新增一个Segment。
(02) 将key-value键值对添加到Segment片段中。
final V put(K key, int hash, V value, boolean onlyIfAbsent) { // tryLock()获取锁，成功返回true，失败返回false。 // 获取锁失败的话，则通过scanAndLockForPut()获取锁，并返回”要插入的key-value“对应的”HashEntry链表“。 HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value); V oldValue; try { // tab代表”当前Segment中的HashEntry数组“ HashEntry<K,V>[] tab = table; // 根据”hash值“获取”HashEntry数组中对应的HashEntry链表“ int index = (tab.length - 1) & hash; HashEntry<K,V> first = entryAt(tab, index); for (HashEntry<K,V> e = first;;) { // 如果”HashEntry链表中的当前HashEntry节点“不为null， if (e != null) { K k; // 当”要插入的key-value键值对“已经存在于”HashEntry链表中“时，先保存原有的值。 // 若”onlyIfAbsent“为true，即”要插入的key不存在时才插入”，则直接退出； // 否则，用新的value值覆盖原有的原有的值。 if ((k = e.key) == key || (e.hash == hash && key.equals(k))) { oldValue = e.value; if (!onlyIfAbsent) { e.value = value; ++modCount; } break; } e = e.next; } else { // 如果node非空，则将first设置为“node的下一个节点”。 // 否则，新建HashEntry链表 if (node != null) node.setNext(first); else node = new HashEntry<K,V>(hash, key, value, first); int c = count + 1; // 如果添加key-value键值对之后，Segment中的元素超过阈值(并且，HashEntry数组的长度没超过限制)，则rehash； // 否则，直接添加key-value键值对。 if (c > threshold && tab.length < MAXIMUM_CAPACITY) rehash(node); else setEntryAt(tab, index, node); ++modCount; count = c; oldValue = null; break; } } } finally { // 释放锁 unlock(); } return oldValue; }
说明：
put()的作用是将key-value键值对插入到“当前Segment对应的HashEntry中”，在插入前它会获取Segment对应的互斥锁，插入后会释放锁。具体的插入过程如下：
(01) 首先根据“hash值”获取“当前Segment的HashEntry数组对象”中的“HashEntry节点”，每个HashEntry节点都是一个单向链表。
(02) 接着，遍历HashEntry链表。
若在遍历HashEntry链表时，找到与“要key-value键值对”对应的节点，即“要插入的key-value键值对”的key已经存在于HashEntry链表中。则根据onlyIfAbsent进行判断，若onlyIfAbsent为true，即“当要插入的key不存在时才插入”，则不进行插入，直接返回；否则，用新的value值覆盖原始的value值，然后再返回。
若在遍历HashEntry链表时，没有找到与“要key-value键值对”对应的节点。当node!=null时，即在scanAndLockForPut()获取锁时，已经新建了key-value对应的HashEntry节点，则”将HashEntry添加到Segment中“；否则，新建key-value对应的HashEntry节点，然后再“将HashEntry添加到Segment中”。 在”将HashEntry添加到Segment中“前，会判断是否需要rehash。如果在添加key-value键值之后，容量会超过阈值，并且HashEntry数组的长度没有超过限制，则进行rehash；否则，直接通过setEntryAt()将key-value键值对添加到Segment中。
在介绍rehash()和setEntryAt()之前，我们先看看自旋函数scanAndLockForPut()。下面是它的源码：
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) { // 第一个HashEntry节点 HashEntry<K,V> first = entryForHash(this, hash); // 当前的HashEntry节点 HashEntry<K,V> e = first; HashEntry<K,V> node = null; // 重复计数(自旋计数器) int retries = -1; // negative while locating node // 查找”key-value键值对“在”HashEntry链表上对应的节点“； // 若找到的话，则不断的自旋；在自旋期间，若通过tryLock()获取锁成功则返回；否则自旋MAX_SCAN_RETRIES次数之后，强制获取”锁“并退出。 // 若没有找到的话，则新建一个HashEntry链表。然后不断的自旋。 // 此外，若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋工作！ while (!tryLock()) { HashEntry<K,V> f; // to recheck first below // 1. retries<0的处理情况 if (retries < 0) { // 1.1 如果当前的HashEntry节点为空(意味着，在该HashEntry链表上上没有找到”要插入的键值对“对应的节点)，而且node=null；则新建HashEntry链表。 if (e == null) { if (node == null) // speculatively create node node = new HashEntry<K,V>(hash, key, value, null); retries = 0; } // 1.2 如果当前的HashEntry节点是”要插入的键值对在该HashEntry上对应的节点“，则设置retries=0 else if (key.equals(e.key)) retries = 0; // 1.3 设置为下一个HashEntry。 else e = e.next; } // 2. 如果自旋次数超过限制，则获取“锁”并退出 else if (++retries > MAX_SCAN_RETRIES) { lock(); break; } // 3. 当“尝试了偶数次”时，就获取“当前Segment的第一个HashEntry”，即f。 // 然后，通过f!=first来判断“当前Segment的第一个HashEntry是否发生了改变”。 // 若是的话，则重置e，first和retries的值，并重新遍历。 else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) { e = first = f; // re-traverse if entry changed retries = -1; } } return node; }
说明：
scanAndLockForPut()的目标是获取锁。流程如下：
它首先会调用entryForHash()，根据hash值获取”当前Segment中对应的HashEntry节点(first)，即找到对应的HashEntry链表“。
紧接着进入while循环。在while循环中，它会遍历”HashEntry链表(e)“，查找”要插入的key-value键值对“在”该HashEntry链表上对应的节点“。
若找到的话，则不断的自旋，即不断的执行while循环。在自旋期间，若通过tryLock()获取锁成功则返回；否则，在自旋MAX_SCAN_RETRIES次数之后，强制获取锁并退出。
若没有找到的话，则新建一个HashEntry链表，然后不断的自旋。在自旋期间，若通过tryLock()获取锁成功则返回；否则，在自旋MAX_SCAN_RETRIES次数之后，强制获取锁并退出。
此外，若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋工作！
理解scanAndLockForPut()时，务必要联系”哈希表“的数据结构。一个Segment本身就是一个哈希表，Segment中包含了”HashEntry数组“对象，而每一个HashEntry对象本身是一个”单向链表“。
下面看看rehash()的实现代码。
private void rehash(HashEntry<K,V> node) { HashEntry<K,V>[] oldTable = table; // ”Segment中原始的HashEntry数组的长度“ int oldCapacity = oldTable.length; // ”Segment中新HashEntry数组的长度“ int newCapacity = oldCapacity << 1; // 新的阈值 threshold = (int)(newCapacity * loadFactor); // 新的HashEntry数组 HashEntry<K,V>[] newTable = (HashEntry<K,V>[]) new HashEntry[newCapacity]; int sizeMask = newCapacity - 1; // 遍历”原始的HashEntry数组“， // 将”原始的HashEntry数组“中的每个”HashEntry链表“的值，都复制到”新的HashEntry数组的HashEntry元素“中。 for (int i = 0; i < oldCapacity ; i++) { // 获取”原始的HashEntry数组“中的”第i个HashEntry链表“ HashEntry<K,V> e = oldTable[i]; if (e != null) { HashEntry<K,V> next = e.next; int idx = e.hash & sizeMask; if (next == null) // Single node on list newTable[idx] = e; else { // Reuse consecutive sequence at same slot HashEntry<K,V> lastRun = e; int lastIdx = idx; for (HashEntry<K,V> last = next; last != null; last = last.next) { int k = last.hash & sizeMask; if (k != lastIdx) { lastIdx = k; lastRun = last; } } newTable[lastIdx] = lastRun; // 将”原始的HashEntry数组“中的”HashEntry链表(e)“的值，都复制到”新的HashEntry数组的HashEntry“中。 for (HashEntry<K,V> p = e; p != lastRun; p = p.next) { V v = p.value; int h = p.hash; int k = h & sizeMask; HashEntry<K,V> n = newTable[k]; newTable[k] = new HashEntry<K,V>(h, p.key, v, n); } } } } // 将新的node节点添加到“Segment的新HashEntry数组(newTable)“中。 int nodeIndex = node.hash & sizeMask; // add the new node node.setNext(newTable[nodeIndex]); newTable[nodeIndex] = node; table = newTable; }
说明：rehash()的作用是将”Segment的容量“变为”原始的Segment容量的2倍“。
在将原始的数据拷贝到“新的Segment”中后，会将新增加的key-value键值对添加到“新的Segment”中。
setEntryAt()的源码如下：
static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i, HashEntry<K,V> e) { UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e); }
UNSAFE是Segment类中定义的“静态sun.misc.Unsafe”对象。源码如下：
static final sun.misc.Unsafe UNSAFE;
Unsafe.java在openjdk6中的路径是：openjdk6/jdk/src/share/classes/sun/misc/Unsafe.java。其中，putOrderedObject()的源码下：
public native void putOrderedObject(Object o, long offset, Object x);
说明：putOrderedObject()是一个本地方法。
它会设置obj对象中offset偏移地址对应的object型field的值为指定值。它是一个有序或者有延迟的putObjectVolatile()方法，并且不保证值的改变被其他线程立即看到。只有在field被volatile修饰并且期望被意外修改的时候，使用putOrderedObject()才有用。
总之，setEntryAt()的目的是设置tab中第i位置元素的值为e，且该设置会有延迟。
4 删除
下面以remove(Object key)来对ConcurrentHashMap中的删除操作来进行说明。
public V remove(Object key) { int hash = hash(key); // 根据hash值，找到key对应的Segment片段。 Segment<K,V> s = segmentForHash(hash); return s == null ? null : s.remove(key, hash, null); }
说明：remove()首先根据“key的计算出来的哈希值”找到对应的Segment片段，然后再从该Segment片段中删除对应的“key-value键值对”。
remove()的方法如下：
final V remove(Object key, int hash, Object value) { // 尝试获取Segment对应的锁。 // 尝试失败的话，则通过scanAndLock()来获取锁。 if (!tryLock()) scanAndLock(key, hash); V oldValue = null; try { // 根据“hash值”找到“Segment的HashEntry数组”中对应的“HashEntry节点(e)”，该HashEntry节点是一HashEntry个链表。 HashEntry<K,V>[] tab = table; int index = (tab.length - 1) & hash; HashEntry<K,V> e = entryAt(tab, index); HashEntry<K,V> pred = null; // 遍历“HashEntry链表”，删除key-value键值对 while (e != null) { K k; HashEntry<K,V> next = e.next; if ((k = e.key) == key || (e.hash == hash && key.equals(k))) { V v = e.value; if (value == null || value == v || value.equals(v)) { if (pred == null) setEntryAt(tab, index, next); else pred.setNext(next); ++modCount; --count; oldValue = v; } break; } pred = e; e = next; } } finally { // 释放锁 unlock(); } return oldValue; }
说明：remove()的目的就是删除key-value键值对。在删除之前，它会获取到Segment的互斥锁，在删除之后，再释放锁。
它的删除过程也比较简单，它会先根据hash值，找到“Segment的HashEntry数组”中对应的“HashEntry”节点。根据Segment的数据结构，我们知道Segment中包含一个HashEntry数组对象，而每一个HashEntry本质上是一个单向链表。 在找到“HashEntry”节点之后，就遍历该“HashEntry”节点对应的链表，找到key-value键值对对应的节点，然后删除。
下面对scanAndLock()进行说明。它的源码如下：
private void scanAndLock(Object key, int hash) { // 第一个HashEntry节点 HashEntry<K,V> first = entryForHash(this, hash); HashEntry<K,V> e = first; int retries = -1; // 查找”key-value键值对“在”HashEntry链表上对应的节点“； // 无论找没找到，最后都会不断的自旋；在自旋期间，若通过tryLock()获取锁成功则返回；否则自旋MAX_SCAN_RETRIES次数之后，强制获取”锁“并退出。 // 若在自旋期间，HashEntry链表的表头发生变化；则重新进行查找和自旋！ while (!tryLock()) { HashEntry<K,V> f; if (retries < 0) { // 如果“遍历完该HashEntry链表，仍然没找到”要删除的键值对“对应的节点” // 或者“在该HashEntry链表上找到”要删除的键值对“对应的节点”，则设置retries=0 // 否则，设置e为下一个HashEntry节点。 if (e == null || key.equals(e.key)) retries = 0; else e = e.next; } // 自旋超过限制次数之后，获取锁并退出。 else if (++retries > MAX_SCAN_RETRIES) { lock(); break; } // 当“尝试了偶数次”时，就获取“当前Segment的第一个HashEntry”，即f。 // 然后，通过f!=first来判断“当前Segment的第一个HashEntry是否发生了改变”。 // 若是的话，则重置e，first和retries的值，并重新遍历。 else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) { e = first = f; retries = -1; } } }
说明：scanAndLock()的目标是获取锁。它的实现与scanAndLockForPut()类似，这里就不再过多说明。
总结：ConcurrentHashMap是线程安全的哈希表，它是通过“锁分段”来实现的。ConcurrentHashMap中包括了“Segment(锁分段)数组”，每个Segment就是一个哈希表，而且也是可重入的互斥锁。第一，Segment是哈希表表现在，Segment包含了“HashEntry数组”，而“HashEntry数组”中的每一个HashEntry元素是一个单向链表。即Segment是通过链式哈希表。第二，Segment是可重入的互斥锁表现在，Segment继承于ReentrantLock，而ReentrantLock就是可重入的互斥锁。
对于ConcurrentHashMap的添加，删除操作，在操作开始前，线程都会获取Segment的互斥锁；操作完毕之后，才会释放。而对于读取操作，它是通过volatile去实现的，HashEntry数组是volatile类型的，而volatile能保证“即对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入”，即我们总能读到其它线程写入HashEntry之后的值。 以上这些方式，就是ConcurrentHashMap线程安全的实现原理。
ConcurrentHashMap示例
下面，我们通过一个例子去对比HashMap和ConcurrentHashMap。
1 import java.util.*; 2 import java.util.concurrent.*; 3 4 /* 5 * ConcurrentHashMap是“线程安全”的哈希表，而HashMap是非线程安全的。 6 * 7 * 下面是“多个线程同时操作并且遍历map”的示例 8 * (01) 当map是ConcurrentHashMap对象时，程序能正常运行。 9 * (02) 当map是HashMap对象时，程序会产生ConcurrentModificationException异常。 10 * 11 * @author skywang 12 */ 13 public class ConcurrentHashMapDemo1 { 14 15 // TODO: map是HashMap对象时，程序会出错。 16 //private static Map<String, String> map = new HashMap<String, String>(); 17 private static Map<String, String> map = new ConcurrentHashMap<String, String>(); 18 public static void main(String[] args) { 19 20 // 同时启动两个线程对map进行操作！ 21 new MyThread("ta").start(); 22 new MyThread("tb").start(); 23 } 24 25 private static void printAll() { 26 String key, value; 27 Iterator iter = map.entrySet().iterator(); 28 while(iter.hasNext()) { 29 Map.Entry entry = (Map.Entry)iter.next(); 30 key = (String)entry.getKey(); 31 value = (String)entry.getValue(); 32 System.out.print(key+" - "+value+", "); 33 } 34 System.out.println(); 35 } 36 37 private static class MyThread extends Thread { 38 MyThread(String name) { 39 super(name); 40 } 41 @Override 42 public void run() { 43 int i = 0; 44 while (i++ < 6) { 45 // “线程名” + "-" + "序号" 46 String val = Thread.currentThread().getName()+i; 47 map.put(String.valueOf(i), val); 48 // 通过“Iterator”遍历map。 49 printAll(); 50 } 51 } 52 } 53 }
(某一次)运行结果：
1 - tb1, 1 - tb1, 1 - tb1, 1 - tb1, 2 - tb2, 2 - tb2, 1 - tb1, 3 - ta3, 1 - tb1, 2 - tb2, 3 - tb3, 1 - tb1, 2 - tb2, 3 - tb3, 1 - tb1, 4 - tb4, 3 - tb3, 2 - tb2, 4 - tb4, 1 - tb1, 2 - tb2, 5 - ta5, 1 - tb1, 3 - tb3, 5 - tb5, 4 - tb4, 3 - tb3, 2 - tb2, 4 - tb4, 1 - tb1, 2 - tb2, 5 - tb5, 1 - tb1, 6 - tb6, 5 - tb5, 3 - tb3, 6 - tb6, 4 - tb4, 3 - tb3, 2 - tb2, 4 - tb4, 2 - tb2,
结果说明：如果将源码中的map改成HashMap对象时，程序会产生ConcurrentModificationException异常。
更多内容
2. Java多线程系列--“JUC集合”02之 CopyOnWriteArrayList
3. Java多线程系列--“JUC集合”03之 CopyOnWriteArraySet