ConcurrentMap介绍： http://donald-draper.iteye.com/blog/2361719
HashMap是线程非安全的，Hashtable是线程安全的，并发访问支持较差，但已经过时，今天我们来看，并发包中的
线程安全且可并发访问的ConcurrentHashMap
package java.util.concurrent;
import java.util.concurrent.locks.*;
import java.util.*;
import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* A hash table supporting full concurrency of retrievals and
* adjustable expected concurrency for updates. This class obeys the
* same functional specification as {@link java.util.Hashtable}, and
* includes versions of methods corresponding to each method of
* <tt>Hashtable</tt>. However, even though all operations are
* thread-safe, retrieval operations do [i]not[/i] entail locking,
* and there is [i]not[/i] any support for locking the entire table
* in a way that prevents all access. This class is fully
* interoperable with <tt>Hashtable</tt> in programs that rely on its
* thread safety but not on its synchronization details.
*
ConcurrentHashMap提供完全线程安全的并发访问。ConcurrentHashMap与HashTable的
功能基本相同。即使所有操作是线程安全，检索操作不许要lock，也不支持lock the
entry table，那样会阻止所有访问。在编程的时候ConcurrentHashMap与HashTable是
协作的，使用哪一个依赖于是否线程安全，而不是，是否需要同步。
* <p> Retrieval operations (including <tt>get</tt>) generally do not
* block, so may overlap with update operations (including
* <tt>put</tt> and <tt>remove</tt>). Retrievals reflect the results
* of the most recently [i]completed[/i] update operations holding
* upon their onset. For aggregate operations such as <tt>putAll</tt>
* and <tt>clear</tt>, concurrent retrievals may reflect insertion or
* removal of only some entries. Similarly, Iterators and
* Enumerations return elements reflecting the state of the hash table
* at some point at or since the creation of the iterator/enumeration.
* They do [i]not[/i] throw {@link ConcurrentModificationException}.
* However, iterators are designed to be used by only one thread at a time.
*
检索操作（get等）一般不会阻塞，也许会与更新操作（put，remove等）出现overlap（重叠）。
检索操作反应的是最近更新操作完成的结果。进一步说，putAll和clear操作，并发检索也许
会反应插入或移除Entry的结果。相似的，Iterators和Enumerations返回的Entry，反应者
hash table在某一点，比如创建iterator/enumeration。它们并不会抛出异常，iterators
设计为只能有一个线程访问，在同一时间点。
* <p> The allowed concurrency among update operations is guided by
* the optional <tt>concurrencyLevel</tt> constructor argument
* (default <tt>16</tt>), which is used as a hint for internal sizing. The
* table is internally partitioned to try to permit the indicated
* number of concurrent updates without contention. Because placement
* in hash tables is essentially random, the actual concurrency will
* vary. Ideally, you should choose a value to accommodate as many
* threads as will ever concurrently modify the table. Using a
* significantly higher value than you need can waste space and time,
* and a significantly lower value can lead to thread contention. But
* overestimates and underestimates within an order of magnitude do
* not usually have much noticeable impact. A value of one is
* appropriate when it is known that only one thread will modify and
* all others will only read. Also, resizing this or any other kind of
* hash table is a relatively slow operation, so, when possible, it is
* a good idea to provide estimates of expected table sizes in
* constructors.
*
ConcurrentHashMap可以同时并发访问，并发数量与构造函数的concurrencyLevel有关，
默认为16，concurrencyLevel表示内部的hashtable的容量。内部的hash table是分块的，块
的数量表示无竞争的情况下，可以并发更新的数量。由于元素放到hash table中，是随机的，
实际的并发数，以实际为准。理想情况下，我们应该选择一个合适值，使更多的线程可以同时
修改hash table。用于个较高的值，可能会浪费不必要的空间和时间，太低的话，将导致
线程的竞争。当时在一个数量级的情况下过多或过少，没有太有的不同。一个近似的值为
当一个线程修改，可以有多少个线程可进行读操作。重新扩容或其他种类hash table是一个
较慢的操作，如果可能的话，在构造hash table的时候，最后给一个预估的size。
* <p>This class and its views and iterators implement all of the
* [i]optional[/i] methods of the {@link Map} and {@link Iterator}
* interfaces.
*
ConcurrentHashMap实现所有Map接口中的视图和iterators。这有点像hash table，而不是
HashMap，ConcurrentHashMap不允许key和value为null。
* <p> Like {@link Hashtable} but unlike {@link HashMap}, this class
* does [i]not[/i] allow <tt>null</tt> to be used as a key or value.
*
* <p>This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @since 1.5
* @author Doug Lea
* @param <K> the type of keys maintained by this map
* @param <V> the type of mapped values
*/
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
private static final long serialVersionUID = 7249069246763182397L;
/*
* The basic strategy is to subdivide the table among Segments,
* each of which itself is a concurrently readable hash table. To
* reduce footprint, all but one segments are constructed only
* when first needed (see ensureSegment). To maintain visibility
* in the presence of lazy construction, accesses to segments as
* well as elements of segment's table must use volatile access,
* which is done via Unsafe within methods segmentAt etc
* below. These provide the functionality of AtomicReferenceArrays
* but reduce the levels of indirection. Additionally,
* volatile-writes of table elements and entry "next" fields
* within locked operations use the cheaper "lazySet" forms of
* writes (via putOrderedObject) because these writes are always
* followed by lock releases that maintain sequential consistency
* of table updates.
*
ConcurrentHashMap最基本的策略是将table分布在不同的Segments，每个
Segments都是一个并发的可读hash table。 To reduce footprint, all but
one segments are constructed only when first needed (see ensureSegment).
（为了减少footprint，当需要的时候，我们才构造segments）。
为了保证懒构造的可见性，访问segments和访问segments中table中elements一样，
必须用volatile访问，实现的方式是通过Unsafe和segmentAt等。
这个方式提供了AtomicReferenceArrays的功能，除了减少间接访问的次数。
另外，volatile-writes table元素和修改Entry的next指针，通过putOrderedObject，
使用比较简单的lazySet形式，因为这些写操作总是跟着lock的释放，以维持
表更新的一致性。
* Historical note: The previous version of this class relied
* heavily on "final" fields, which avoided some volatile reads at
* the expense of a large initial footprint. Some remnants of
* that design (including forced construction of segment 0) exist
* to ensure serialization compatibility.
*/
经验建议：ConcurrentHashMap的先前版本，过多的依赖于final，这避免了
在大量初始化封装实体的情况，可见性的读操作。ConcurrentHashMap有一些
保留性的设计，不如在构造是强制构造segment，以保证序列化的兼容性。
/* ---------------- Constants -------------- */
/**
* The default initial capacity for this table,
* used when not otherwise specified in a constructor.
*/
table的默认容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* The default load factor for this table, used when not
* otherwise specified in a constructor.
*/
默认的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The default concurrency level for this table, used when not
* otherwise specified in a constructor.
*/
table的并发访问级别，在构造中非必须
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* The maximum capacity, used if a higher value is implicitly
* specified by either of the constructors with arguments. MUST
* be a power of two <= 1<<30 to ensure that entries are indexable
* using ints.
*/
最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The minimum capacity for per-segment tables. Must be a power
* of two, at least two to avoid immediate resizing on next use
* after lazy construction.
*/
每个片段 table的最小容量，默认至少为2，避免当next指针使用时，需要立即扩容
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
/**
* The maximum number of segments to allow; used to bound
* constructor arguments. Must be power of two less than 1 << 24.
*/
最大片段数
static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
/**
* Number of unsynchronized retries in size and containsValue
* methods before resorting to locking. This is used to avoid
* unbounded retries if tables undergo continuous modification
* which would make it impossible to obtain an accurate result.
*/
在重排序lock之前，非同步化尝试调用size和containsValue方法的次数。
这个为了避免无限制的尝试，当table需要持续性的修改，这样做是为了
尽可能的保证获取准确的结果
static final int RETRIES_BEFORE_LOCK = 2;
/* ---------------- Fields -------------- */
/**
* holds values which can't be initialized until after VM is booted.
*/
private static class Holder {
/**
* Enable alternative hashing of String keys?
*
* <p>Unlike the other hash map implementations we do not implement a
* threshold for regulating whether alternative hashing is used for
* String keys. Alternative hashing is either enabled for all instances
* or disabled for all instances.
*/
static final boolean ALTERNATIVE_HASHING;
static {
// Use the "threshold" system property even though our threshold
// behaviour is "ON" or "OFF".
String altThreshold = java.security.AccessController.doPrivileged(
new sun.security.action.GetPropertyAction(
"jdk.map.althashing.threshold"));
int threshold;
try {
threshold = (null != altThreshold)
? Integer.parseInt(altThreshold)
: Integer.MAX_VALUE;
// disable alternative hashing if -1
if (threshold == -1) {
threshold = Integer.MAX_VALUE;
}
if (threshold < 0) {
throw new IllegalArgumentException("value must be positive integer.");
}
} catch(IllegalArgumentException failed) {
throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
}
ALTERNATIVE_HASHING = threshold <= MAXIMUM_CAPACITY;
}
}
/**
* A randomizing value associated with this instance that is applied to
* hash code of keys to make hash collisions harder to find.
*/
hash种子
private transient final int hashSeed = randomHashSeed(this);
//获取ConcurrentHashMap实例的随机种子
private static int randomHashSeed(ConcurrentHashMap instance) {
if (sun.misc.VM.isBooted() && Holder.ALTERNATIVE_HASHING) {
return sun.misc.Hashing.randomHashSeed(instance);
}
return 0;
}
/**
* Mask value for indexing into segments. The upper bits of a
* key's hash code are used to choose the segment.
*/
//片段索引的掩码，可以hash值的高位，用于选择片段索引
final int segmentMask;
/**
* Shift value for indexing within segments.
*/
索引在片段中的偏移量
final int segmentShift;
/**
* The segments, each of which is a specialized hash table.
*/
片段是一个特殊的Hash table；
final Segment<K,V>[] segments;
transient Set<K> keySet;//Key集合
transient Set<Map.Entry<K,V>> entrySet;//Entry集合
transient Collection<V> values;//vaule集合
}
先看一下HashEntry
/**
* ConcurrentHashMap list entry. Note that this is never exported
* out as a user-visible Map.Entry.
*/
//HashEntry内部使用，对用户不可见
static final class HashEntry<K,V> {
final int hash;//hash值
final K key;//key
//key和hash值不可修改
volatile V value;//value值和next内存可见
volatile HashEntry<K,V> next;
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
/**
* Sets next field with volatile write semantics. (See above
* about use of putOrderedObject.)
*/
//使用UNSAFE的putOrderedObject设置next指针
final void setNext(HashEntry<K,V> n) {
UNSAFE.putOrderedObject(this, nextOffset, n);
}
// Unsafe mechanics
static final sun.misc.Unsafe UNSAFE;
static final long nextOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = HashEntry.class;
nextOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("next"));
} catch (Exception e) {
throw new Error(e);
}
}
}
再来看一下Segment定义
/**
* Segments are specialized versions of hash tables. This
* subclasses from ReentrantLock opportunistically, just to
* simplify some locking and avoid separate construction.
*/
//片段是一个特殊版本的hash table。为可重入锁ReentrantLock的子类，
仅仅为了简化加锁和避免分离构造
static final class Segment<K,V> extends ReentrantLock implements Serializable {
/*
* Segments maintain a table of entry lists that are always
* kept in a consistent state, so can be read (via volatile
* reads of segments and tables) without locking. This
* requires replicating nodes when necessary during table
* resizing, so the old lists can be traversed by readers
* still using old version of table.
*
Segments维护者一个Entry列表table，总是保持一致性状态，因此可以
不通过锁，我们就可以读取segments and tables的最新值。在重新扩容的时候，
旧的entry列表被迁移到新的segments and tables上，读线程，能可以用旧版本的table。
* This class defines only mutative methods requiring locking.
* Except as noted, the methods of this class perform the
* per-segment versions of ConcurrentHashMap methods. (Other
* methods are integrated directly into ConcurrentHashMap
* methods.) These mutative methods use a form of controlled
* spinning on contention via methods scanAndLock and
* scanAndLockForPut. These intersperse tryLocks with
* traversals to locate nodes. The main benefit is to absorb
* cache misses (which are very common for hash tables) while
* obtaining locks so that traversal is faster once
* acquired. We do not actually use the found nodes since they
* must be re-acquired under lock anyway to ensure sequential
* consistency of updates (and in any case may be undetectably
* stale), but they will normally be much faster to re-locate.
* Also, scanAndLockForPut speculatively creates a fresh node
* to use in put if no node is found.
*/
Segments只会在修改hash table的方法中，是用lock，之所以加锁，是为了
保证ConcurrentHashMap中每segment的一致性。而其他一些方法，则直接放在
ConcurrentHashMap中。这些更新table的方式是通过scanAndLock和scanAndLockForPut
方法，控制自旋竞争。tryLocks方法，只会在遍历table时，锁住NODE。
这样做的好处是，在遍历table的情况，尽快获取locks，以保证缓存的可用性与可靠性。
为了保证更新的一致性，在锁住的情况下，由于要重新获取锁，我们一般不会访问锁住的节点。
但实际上的速度，要比重新定位要快。如果node不存在，则scanAndLockForPut会创建一个新的节点
放到table中。
private static final long serialVersionUID = 2249069246763182397L;
/**
* The maximum number of times to tryLock in a prescan before
* possibly blocking on acquire in preparation for a locked
* segment operation. On multiprocessors, using a bounded
* number of retries maintains cache acquired while locating
* nodes.
*/
最大尝试获取锁次数，tryLock可能会阻塞，准备锁住segment操作获取锁。
在多处理器中，用一个有界的尝试次数，保证在定位node的时候，可以从缓存直接获取。
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
/**
* The per-segment table. Elements are accessed via
* entryAt/setEntryAt providing volatile semantics.
*/
segment内部的Hash table，访问HashEntry，通过具有volatile的entryAt/setEntryAt方法
transient volatile HashEntry<K,V>[] table;
/**
* The number of elements. Accessed only either within locks
* or among other volatile reads that maintain visibility.
*/
segment的table中HashEntry的数量，只有在lock或其他保证可见性的volatile reads
中，才可以访问count
transient int count;
/**
* The total number of mutative operations in this segment.
* Even though this may overflows 32 bits, it provides
* sufficient accuracy for stability checks in CHM isEmpty()
* and size() methods. Accessed only either within locks or
* among other volatile reads that maintain visibility.
*/
在segment上所有的修改操作数。尽管可能会溢出，但它为isEmpty和size方法，
提供了有效准确稳定的检查或校验。只有在lock或其他保证可见性的volatile reads
中，才可以访问
transient int modCount;
/**
* The table is rehashed when its size exceeds this threshold.
* (The value of this field is always <tt>(int)(capacity *
* loadFactor)</tt>.)
*/
table重新hash的临界条件，为(capacity * loadFactor)
transient int threshold;
/**
* The load factor for the hash table. Even though this value
* is same for all segments, it is replicated to avoid needing
* links to outer object.
* @serial
*/
hash table的负载因子，尽管这个值是通过复制的，所有的segments相等，
为了避免需要连接到外部object
final float loadFactor;
//构造Segment，负载因子，临界条件，table
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
}
从上面来看：
Segment拥有与ConCurrentHashMap相同的负载因子，临界条件，拥有一个hash table。
来看Segment的put操作
//Segment
/*如果key存在且onlyIfAbsent为false，则更新旧值，否则创建新hash Entry，添加到table中
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//尝试获取锁，获取失败返回node为null，否则scanAndLockForPut
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
//获取table索引
int index = (tab.length - 1) & hash;
//获取table索引为index的第一个HashEntry
HashEntry<K,V> first = entryAt(tab, index);
//遍历table的index索引上的HashEntry链
for (HashEntry<K,V> e = first;;) {
if (e != null) {
//如果HashEntry不为null
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
//如果存在key且hash相等，onlyIfAbsent为false，则更新旧值为value
e.value = value;
//修改数+1
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
//如果创建的节点不为null，则将node放在table的index索引对应的HashEntry链的头部
node.setNext(first);
else
//否创建新的HashEntry，放在链头，next指向链的原始头部。
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//如果table的Hash Entry数量size大于临界条件，且小于最大容量，则重新hash
rehash(node);
else
//添加node到table的索引对应的链表
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
Segment的put操，我们有一下几点要分析
final V put(K key, int hash, V value, boolean onlyIfAbsent)
1.
//尝试获取锁，获取失败返回node为null，否则scanAndLockForPut
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
2.
HashEntry<K,V>[] tab = table; //获取table索引 int index = (tab.length - 1) & hash; //获取table索引为index的第一个HashEntry HashEntry<K,V> first = entryAt(tab, index);
3.
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//如果table的Hash Entry数量size大于临界条件，且小于最大容量，则重新hash
rehash(node);
4.
else //添加node到table的索引对应的链表 setEntryAt(tab, index, node);
我们一点一点的看，
1.
//尝试获取锁，获取失败返回node为null，否则scanAndLockForPut
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
//Segment
/**
* Scans for a node containing given key while trying to
* acquire lock, creating and returning one if not found. Upon
* return, guarantees that lock is held. UNlike in most
* methods, calls to method equals are not screened（筛选）: Since
* traversal speed doesn't matter, we might as well help warm
* up the associated code and accesses as well.
*
在尝试获取锁失败时，遍历HashEntry，确认key存不存在，如果不存在，则创建一个新Hash Entry,返回，
保证持有锁。
* @return a new node if key not found, else null
*/
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
//根据Segment片段和hash值，返回对应的Hash Entry
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
int retries = -1; // negative while locating node，运行尝试的次数
//当尝试获取锁失败
while (!tryLock()) {
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
//当尝试获取锁失败，且尝试次数小于0，首次尝试，如果Entry为null，则创建新节点
if (e == null) {
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
else if (key.equals(e.key))
retries = 0;
else
e = e.next;
}
else if (++retries > MAX_SCAN_RETRIES) {
//如果尝试次数大于最大尝试次数，则锁住，跳出循环
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
/* Gets the table entry for the given segment and hash
*/
//根据Segment片段和hash值，返回对应的Hash Entry
@SuppressWarnings("unchecked")
static final <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) {
HashEntry<K,V>[] tab;
return (seg == null || (tab = seg.table) == null) ? null :
(HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
}
scanAndLockForPut函数的作用主要是：
在尝试获取锁失败时，遍历HashEntry，确认key存不存在，如果不存在，
则创建一个新Hash Entry,返回，确保一直持有锁。
2.
HashEntry<K,V>[] tab = table; //获取table索引 int index = (tab.length - 1) & hash; //获取table索引为index的第一个HashEntry HashEntry<K,V> first = entryAt(tab, index);
/**
* Gets the ith element of given table (if nonnull) with volatile
* read semantics. Note: This is manually integrated into a few
* performance-sensitive methods to reduce call overhead.
*/
@SuppressWarnings("unchecked")
//返回片段table中，索引i对应的HashEntry 链的第一个HashEntry
static final <K,V> HashEntry<K,V> entryAt(HashEntry<K,V>[] tab, int i) {
return (tab == null) ? null :
(HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)i << TSHIFT) + TBASE);
}
3.
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//如果table的Hash Entry数量size大于临界条件，且小于最大容量，则重新hash
rehash(node);
/**
* Doubles size of table and repacks entries, also adding the
* given node to new table
*/
@SuppressWarnings("unchecked")
private void rehash(HashEntry<K,V> node) {
/*
* Reclassify nodes in each list to new table. Because we
* are using power-of-two expansion, the elements from
* each bin must either stay at same index, or move with a
* power of two offset. We eliminate unnecessary node
* creation by catching cases where old nodes can be
* reused because their next fields won't change.
* Statistically, at the default threshold, only about
* one-sixth of them need cloning when a table
* doubles. The nodes they replace will be garbage
* collectable as soon as they are no longer referenced by
* any reader thread that may be in the midst of
* concurrently traversing table. Entry accesses use plain
* array indexing because they are followed by volatile
* table write.
*/
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
//扩容容量为原来的2倍，重新计算临界条件
int newCapacity = oldCapacity << 1;
threshold = (int)(newCapacity * loadFactor);
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
//遍历table，将HashEntry，放在新table的对应的索引HashEntry链上。
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
if (e != null) {
HashEntry<K,V> next = e.next;
//重新获取原始HashEntry在新table中的索引
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;
// Clone remaining nodes
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);
}
}
}
}
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
4.
else //添加node到table的索引对应的链表 setEntryAt(tab, index, node);
/**
* Sets the ith element of given table, with volatile write
* semantics. (See above about use of putOrderedObject.)
*/
//将HashEntry添加到片段table中的索引i对应的HashEntry链中。
static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i,
HashEntry<K,V> e) {
UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
}
从分析上面4步，可以看出，Segment的put操作，首先尝试获取锁，如果获取锁失败，
则Key在片段hash table中的索引，遍历索引对应的Hash Entry链，如找不到key对应
HashEntry,则创建一个HashEntry，这都是在尝试次数小于最大尝试次数MAX_SCAN_RETRIES情况下，MAX_SCAN_RETRIES默认为2。这样做的目的是为确保，进行put操作时，仍持有锁。
然后定位key在片段table中的索引，并放在链头，如果实际size达到临界条件，则重新hash，
创建2倍原始容量的hash table，重新建立hash table。
再看Segment的remove操作
//Segment
/**
* Remove; match on key only if value null, else match both.
*/
从片段的table中移除key，value值相等的hashEntry
final V remove(Object key, int hash, Object value) {
//尝试获取锁失败时，遍历table中key所在索引的HashEntry链表，主要为确保持有锁
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K,V>[] tab = table;
//定位key在table中的hashEntry链表索引
int index = (tab.length - 1) & hash;
HashEntry<K,V> e = entryAt(tab, index);
HashEntry<K,V> pred = null;
//如果索引位置上HashEntry链表存在，则遍历链表，找到对应的HashEntry，则移除
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方法中有一点要看，
//尝试获取锁失败时，遍历table中key所在索引的HashEntry链表，主要为确保持有锁
if (!tryLock())
scanAndLock(key, hash);
来看scanAndLock
//Segment
/**
* Scans for a node containing the given key while trying to
* acquire lock for a remove or replace operation. Upon
* return, guarantees that lock is held. Note that we must
* lock even if the key is not found, to ensure sequential
* consistency of updates.
*/
//如果尝试获取锁失败，则遍历key在table索引链表，查看对应的HashEntry，是否存在，存在则移除
private void scanAndLock(Object key, int hash) {
// similar to but simpler than scanAndLockForPut
//获取key在片段table中的HashEntry链表
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
int retries = -1;
//尝试获取锁失败，则遍历HashEntry链表，如果尝试次数超过最大尝试次数，则lock
while (!tryLock()) {
HashEntry<K,V> f;
if (retries < 0) {
if (e == null || key.equals(e.key))
retries = 0;
else
e = e.next;
}
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f;
retries = -1;
}
}
}
从上面来看
Segment的remove操作，首先尝试获取锁失败，则继续尝试获取锁，在获取锁的过程中，
定位key在片段table的HashEntry链表索引，遍历链表，如果找到对应的HashEntry，则移除，
如果尝试次数超过最大尝试次数，则lock，则遍历链表，找到对应的HashEntry，则移除。
再来看Segment的replace操作
//Segment
final boolean replace(K key, int hash, V oldValue, V newValue) {
if (!tryLock())
scanAndLock(key, hash);
boolean replaced = false;
try {
HashEntry<K,V> e;
for (e = entryForHash(this, hash); e != null; e = e.next) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
if (oldValue.equals(e.value)) {
e.value = newValue;
++modCount;
replaced = true;
}
break;
}
}
} finally {
unlock();
}
return replaced;
}
//Segment
final V replace(K key, int hash, V value) {
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K,V> e;
for (e = entryForHash(this, hash); e != null; e = e.next) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
e.value = value;
++modCount;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
从上面的replace(K key, int hash, V value)和 replace(K key, int hash, V oldValue, V newValue) 来看，与remove的基本思路相同，这里就不在说，唯一的区别是，当替换值时，修改计数要自增1。
再看Segment清除
//Segment
final void clear() {
lock();
try {
HashEntry<K,V>[] tab = table;
for (int i = 0; i < tab.length ; i++)
//设置片段table的索引i的HashEntry链表为null
setEntryAt(tab, i, null);
++modCount;
count = 0;
} finally {
unlock();
}
}
从上面可以看出:Clear锁住整个table。
再看ConcurrentHashMap的构造
/**
* Creates a new, empty map with a default initial capacity (16),
* load factor (0.75) and concurrencyLevel (16).
*/
public ConcurrentHashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
/**
* Creates a new, empty map with the specified initial capacity,
* and with default load factor (0.75) and concurrencyLevel (16).
*
* @param initialCapacity the initial capacity. The implementation
* performs internal sizing to accommodate this many elements.
* @throws IllegalArgumentException if the initial capacity of
* elements is negative.
*/
public ConcurrentHashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
/**
* Creates a new, empty map with the specified initial capacity
* and load factor and with the default concurrencyLevel (16).
*
* @param initialCapacity The implementation performs internal
* sizing to accommodate this many elements.
* @param loadFactor the load factor threshold, used to control resizing.
* Resizing may be performed when the average number of elements per
* bin exceeds this threshold.
* @throws IllegalArgumentException if the initial capacity of
* elements is negative or the load factor is nonpositive
*
* @since 1.6
*/
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}
/**
* Creates a new, empty map with the specified initial
* capacity, load factor and concurrency level.
*
* @param initialCapacity the initial capacity. The implementation
* performs internal sizing to accommodate this many elements.
* @param loadFactor the load factor threshold, used to control resizing.
* Resizing may be performed when the average number of elements per
* bin exceeds this threshold.
* @param concurrencyLevel the estimated number of concurrently
* updating threads. The implementation performs internal sizing
* to try to accommodate this many threads.
concurrencyLevel为并发更数
* @throws IllegalArgumentException if the initial capacity is
* negative or the load factor or concurrencyLevel are
* nonpositive.
*/
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
//参数值，异常，则抛出IllegalArgumentException
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
//ConcurrentHashMap的片段数量
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;//片段偏移量
this.segmentMask = ssize - 1;//片段掩码
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//计算片段中Hash table的容量
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
//创建0片段
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;
}
ConcurrentHashMap的构造主要是计算片段偏移量，片段掩码，临界条件，创建0片段和片段数组；片段数组中，片段的容量，负载因子，临界条件，并发访问量为默认值。
总结：
ConcurrentHashMap是线程安全的，可并发访问，不允许key或value的值为null，默认的容量为16，负载因子为0.75，并发访问量为16。ConcurrentHashMap中有一个Segment数组，默认数组大小为16，Segment中有一个HashEntry数组类似于HashMap中的table，Segment继承了可重入锁ReentrantLock，Segment的修改其hash table的操作都要使用lock。Segment的put操作，首先尝试获取锁，如果获取锁失败，则Key在片段hash table中的索引，遍历索引对应的Hash Entry链，如找不到key对应HashEntry,则创建一个HashEntry，这都是在尝试次数小于最大尝试次数MAX_SCAN_RETRIES情况下，MAX_SCAN_RETRIES默认为2。这样做的目的是为确保，进行put操作时，仍持有锁。然后定位key在片段table中的索引，并放在链头，如果实际size达到临界条件，则重新hash，创建2倍原始容量的hash table，重新建立hash table。Segment的remove操作，首先尝试获取锁失败，则继续尝试获取锁，在获取锁的过程中，定位key在片段table的HashEntry链表索引，遍历链表，如果找到对应HashEntry，则移除，如果尝试次数超过最大尝试次数，则lock，则遍历链表，找到对应的HashEntry，则移除。replace与remove的基本思路相同，唯一的区别是，当替换值时，修改计数要自增1。
put，remove和replace操作是锁住片段table中，key对应的索引HashEntry链表，而Clear为锁住整个table。ConcurrentHashMap通过将所有HashEntry分散在不同的Segment，及锁机制实现了并发访问。
ConcurrentHashMap的剩下部分，我们下一篇再讲。
ConcurrentHashMap解析后续： http://donald-draper.iteye.com/blog/2363201