JDK容器与并发—Map—ConcurrentHashMap

概述

      线程安全的HashMap版本。

1）基本思想：将整个大的hash table进一步细分成小的hash table，即Segment；

2）读不用加锁；写操作在所在的Segmenet上加锁，而不是整个HashMap，Hashtable就是所有方法竞争Hashtable上的锁，导致并发效率低；

3）采用懒构造segment（除了segments[0]），以减少初始化内存。Unsafe类实现了AtomicReferenceArrays的功能，但减少了间接引用的程度。对Segment.table元素、HashEntry.next属性采用更轻量级的“lazySet”写（用Unsafe.putOrderedObject实现，确保用在lock中，其后有unlock释放），以保证table更新的顺序一致性。之前的ConcurrentHashMap类过度依赖final关键字，虽然能避免一些volatile读，但是初始化时需要较大的内存。

4）并发级别由concurrencyLevel参数确定，太大会浪费内存空间和遍历时间，太小则加强竞争；当只有一个线程写，其他线程都是读，则设置为1；

5）迭代器为其创建时或之后的某个时刻ConcurrentHashMap状态，不会抛出ConcurrentModificationException，用来在一个线程中一次使用；

6）尽量避免rehash。

数据结构

      Segment<K,V>数组，每一个Segment又是特殊的hash table，包括HashEntry<K,V>数组，HashEntry为并发版的键值对：

final Segment<K,V>[] segments;	// final方式

static final class Segment<K,V> extends ReentrantLock implements Serializable {
	
	// 在预扫描中，segment阻塞前tryLock尝试的最大数
	// 在多处理器中，采用有限的尝试次数使得在查找节点时缓存
	static final int MAX_SCAN_RETRIES =
		Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;

	// segment的table数组
	// 采用entryAt/setEntryAt提供对其元素的volatile读写
	transient volatile HashEntry<K,V>[] table;

	// segment中元素数目，获取方式采用lock或其他volatile方式
	transient int count;

	// 所在segment的写总数
	// 即使其overflows，也可以保证在isEmpty()、size()使用中的正确性
	// 获取方式采用lock或其他volatile方式
	transient int modCount;

	// segment中table的负载阈值，超过则其table rehash
	transient int threshold;

	// 负载因子，对所有segment都一样。
	// 这个单独作为segment的一个属性是为了避免链接到外部对象
	final float loadFactor;

	Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
		this.loadFactor = lf;
		this.threshold = threshold;
		this.table = tab;
	}
}
 
static final class HashEntry<K,V> {
	// hash、key为final；value、next为volatile
	final int hash;
	final K key;
	volatile V value;
	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;
	}

	// 用UNSAFE.putOrderedObject进行next的volatile写
	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);
		}
	}
}

构造器

相关概念了解：

初始容量：ConcurrentHashMap容量，其初始化完成后，segments长度*Segment容量
Segment容量：Segment.table.length
负载因子：即每一个Segment的负载因子，该值在所有的Segment中是相等的
并发级别：segments.length，在ConcurrentHashMap中锁是针对Segment的
segmentMask：限定在segments的索引范围，即segments.length-1，key hashCode的高位决定segment
segmentShift：在segments索引中，hash码的移位值

采用无参构造的相关参数值：

segments.length = 16
segmentShift = 28
segmentMask = 15
Segment.table.length = 2
Segment.loadFactor = 0.75
Segment.threshold = 1

// 带初始容量、负载因子、并发级别参数构造
// initialCapacity参数：用来确定Segment容量
// loadFactor参数：Segment的负载因子
// concurrencyLevel参数：用来确定segments长度，即并发级别

public ConcurrentHashMap(int initialCapacity,
						 float loadFactor, int concurrencyLevel) {
	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;
	while (ssize < concurrencyLevel) {
		++sshift;
		ssize <<= 1;
	}
	this.segmentShift = 32 - sshift; // 用来确定segment的移位
	this.segmentMask = ssize - 1; // 用来确定segment的掩码，即Segment数组长度-1，key hashCode的高位确定segment index
	if (initialCapacity > MAXIMUM_CAPACITY)
		initialCapacity = MAXIMUM_CAPACITY;
	int c = initialCapacity / ssize; // 初始容量/Segment数组长度，即用来确定Segment容量
		++c;
	int cap = MIN_SEGMENT_TABLE_CAPACITY;
	while (cap < c)
		cap <<= 1; // Segment容量
	// create segments and segments[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;
}

// 带初始容量、负载因子参数构造，默认并发级别为16
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
	this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}

// 带初始容量参数构造，默认负载因子0.75
public ConcurrentHashMap(int initialCapacity) {
	this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

// 无参构造，默认初始容量16
public ConcurrentHashMap() {
	this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

/**
 * Creates a new map with the same mappings as the given map.
 * The map is created with a capacity of 1.5 times the number
 * of mappings in the given map or 16 (whichever is greater),
 * and a default load factor (0.75) and concurrencyLevel (16).
 *
 * @param m the map
 */
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
	this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
				  DEFAULT_INITIAL_CAPACITY),
		 DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
	putAll(m);
}

增删改查

Segment容量调整策略

1）当Segment中键值对数超过负载阈值且table长度小于MAXIMUM_CAPACITY = 1 << 30，则对其table进行容量调整，table容量翻倍；
2）table最大容量为MAXIMUM_CAPACITY = 1 << 30；
3）table容量达到MAXIMUM_CAPACITY 后，如果有put请求，则直接在相应的bucket中链接进来，不会控制键值对的添加；
4）若进行了table的容量调整，需要将旧table关联的键值对重新在新table中确定bucket，再添加进来，也就是所说的hash table rehash，这里可以重用一些旧table的节点，因为next属性是不变的。

// rehash
@SuppressWarnings("unchecked")
private void rehash(HashEntry<K,V> node) {
	// table长度翻倍
	// 由于table长度为2的幂次方，在从就table到新table的rehash过程中，
	// 元素的索引要么不变，要么移位2的幂次方；
	// 一些老的节点因其next属性不变可以重用，在默认的负载阈值下，
	// 只有1/6的元素需要复制。Entry的读取值采用普通的数组索引，这是
	// 因为其后有table的volatile写
	HashEntry<K,V>[] oldTable = table;
	int oldCapacity = oldTable.length;
	int newCapacity = oldCapacity << 1; // table长度翻倍，长度依然为2的幂次方
	threshold = (int)(newCapacity * loadFactor); // 负载阈值
	HashEntry<K,V>[] newTable =
		(HashEntry<K,V>[]) new HashEntry[newCapacity];
	int sizeMask = newCapacity - 1;
	for (int i = 0; i < oldCapacity ; i++) {
		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 { 
				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; // 在新的table中，重用索引相同的老的节点，其next属性不变
				// 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;
}

增、改

确定segments数组中Segment索引、Segment中table数组bucket索引

      基于key的hashCode再哈希产生hash码，用其高位确定Segment索引，用其低位确定bucket索引：

// 对key的hashCode进行再次哈希，对其高位、低位进一步散列  
// 由于segments、Segment.table length为均2的幂次方，所以对那些高位、低位相同的hashCode，容易产生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);
}

// 用hash码的高位在segments中确定index
int j = (hash >>> segmentShift) & segmentMask;

// 用hash码的低位确定bucket index
int index = (tab.length - 1) & hash;

      步骤：
1）根据key的hashCode获取hash码；
2）用hash码的高位确定Segment；
3）将put操作委托给确定的Segment进行put；
4）先采用自旋获取该Segment的锁；
5）用hash码的低位确定该Segment中table的bucket；
6）先遍历该bucket中键值对，确定是否已有相同或hash码相等且key相等的键值对，有则替换新value后返回；否则用key、value、hash创建Entry，将其链接到bucket首位；
7）释放该Segment的锁。

public V put(K key, V value) {
	Segment<K,V> s;
	if (value == null)
		throw new NullPointerException();
	int hash = hash(key);
	int j = (hash >>> segmentShift) & segmentMask;
	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); // 委托给确定的Segment进行put
}

// Segment put
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
	HashEntry<K,V> node = tryLock() ? null :
		scanAndLockForPut(key, hash, value); // 采用自旋，获取锁与遍历bucket热身
	V oldValue;
	try {
		HashEntry<K,V>[] tab = table;
		int index = (tab.length - 1) & hash; // bucketIndex
		HashEntry<K,V> first = entryAt(tab, index); // table元素 volatile读
		for (HashEntry<K,V> e = first;;) {
			if (e != null) { // 先遍历看是否已有键值对
				K k;
				// key相同或hash码相等且key相等
				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 {
				if (node != null)
					node.setNext(first);
				else
					node = new HashEntry<K,V>(hash, key, value, first);
				int c = count + 1;
				if (c > threshold && tab.length < MAXIMUM_CAPACITY)
					rehash(node);
				else
					setEntryAt(tab, index, node); // table元素 volatile写
				++modCount;
				count = c;
				oldValue = null;
				break;
			}
		}
	} finally {
		unlock();
	}
	return oldValue;
}
	
// segments元素volatile读，若不存在，则创建再用CAS写入segments
@SuppressWarnings("unchecked")
private Segment<K,V> ensureSegment(int k) {
	final Segment<K,V>[] ss = this.segments;
	long u = (k << SSHIFT) + SBASE; // raw offset
	Segment<K,V> seg;
	// 对segments中元素进行volatile读，若为null则
	if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
		Segment<K,V> proto = ss[0]; // use segment 0 as prototype
		int cap = proto.table.length;
		float lf = proto.loadFactor;
		int threshold = (int)(cap * lf);
		HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
		if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
			== null) { // 再次检查是否为null
			Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
			while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))// 用CAS方式写
				   == null) {
				if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
					break;
			}
		}
	}
	return seg;
}	
	
// 在尝试获取Segment锁的过程中，遍历hash码所确定的bucket中的节点，
// 如果没有，则创建返回，返回时确保获取到当前Segment锁。这里只采用equals
// 来比较key，这不重要，主要是为了遍历热身。
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
	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) {
			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;
}

// table元素volatile读
@SuppressWarnings("unchecked")
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);
}

// table元素volatile写
static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i,
								   HashEntry<K,V> e) {
	UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
}

删

步骤：
1）根据key的hashCode获取hash码；
2）用hash码的高位确定Segment；
3）将put操作委托给确定的Segment进行remove；
4）先采用自旋获取该Segment的锁；
5）用hash码的低位确定该Segment中table的bucket；
6）遍历该bucket中键值对，确定是否已有相同或hash码相等且key相等的键值对，有则删除；
7）释放该Segment的锁。

public V remove(Object key) {
	int hash = hash(key);
	Segment<K,V> s = segmentForHash(hash);
	return s == null ? null : s.remove(key, hash, null);
}

final V remove(Object key, int hash, Object value) {
	if (!tryLock())
		scanAndLock(key, hash);
	V oldValue = null;
	try {
		HashEntry<K,V>[] tab = table;
		int index = (tab.length - 1) & hash;
		HashEntry<K,V> e = entryAt(tab, index);
		HashEntry<K,V> pred = null;
		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); // 删除的是bucket的第一个节点，volatile写
					else
						pred.setNext(next); // 通过改变next删除节点，next的volatile写
					++modCount;
					--count;
					oldValue = v;
				}
				break;
			}
			pred = e;
			e = next;
		}
	} finally {
		unlock();
	}
	return oldValue;
}

查

步骤：
1）根据key的hashCode获取hash码；
2）用hash码的高位确定Segment；
3）用hash码的低位确定该Segment中table的bucket；
4）遍历该bucket中键值对，确定是否已有相同或hash码相等且key相等的键值对，有则返回关联的value；否则返回null。

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;
	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;
}

其他方法

// 判断ConcurrentHashMap是否为空
// 用segment的modCount来确定调用时间段
public boolean isEmpty() {
	long sum = 0L;
	final Segment<K,V>[] segments = this.segments;
	for (int j = 0; j < segments.length; ++j) {
		Segment<K,V> seg = segmentAt(segments, j);
		if (seg != null) {
			if (seg.count != 0)
				return false;
			sum += seg.modCount;
		}
	}
	if (sum != 0L) { // recheck unless no modifications
		for (int j = 0; j < segments.length; ++j) {
			Segment<K,V> seg = segmentAt(segments, j);
			if (seg != null) {
				if (seg.count != 0)
					return false;
				sum -= seg.modCount;
			}
		}
		if (sum != 0L) // modCount溢不溢出都没有关系，只要sum为0L就表明没有修改
			return false;
	}
	return true;
}

// 获取ConcurrentHashMap的键值对总数
// 用segment的modCount来确定调用时间段
// 先尝试RETRIES_BEFORE_LOCK次数获取size，获取失败则加全锁
public int size() {
	// Try a few times to get accurate count. On failure due to
	// continuous async changes in table, resort to locking.
	final Segment<K,V>[] segments = this.segments;
	int size;
	boolean overflow; // true if size overflows 32 bits
	long sum;         // sum of modCounts
	long last = 0L;   // previous sum
	int retries = -1; // first iteration isn't retry
	try {
		for (;;) {
			if (retries++ == RETRIES_BEFORE_LOCK) {
				for (int j = 0; j < segments.length; ++j)
					ensureSegment(j).lock(); // force creation
			}
			sum = 0L;
			size = 0;
			overflow = false;
			for (int j = 0; j < segments.length; ++j) {
				Segment<K,V> seg = segmentAt(segments, j);
				if (seg != null) {
					sum += seg.modCount;
					int c = seg.count;
					if (c < 0 || (size += c) < 0)
						overflow = true;
				}
			}
			if (sum == last)
				break;
			last = sum;
		}
	} finally {
		if (retries > RETRIES_BEFORE_LOCK) {
			for (int j = 0; j < segments.length; ++j)
				segmentAt(segments, j).unlock();
		}
	}
	return overflow ? Integer.MAX_VALUE : size;
}

迭代器

      HashIterator为迭代器基类，从后往前对ConcurrentHashMap进行全遍历，性能一般，KeyIterator、ValueIterator、EntryIterator都继承于该类：

abstract class HashIterator {
	int nextSegmentIndex;
	int nextTableIndex;
	HashEntry<K,V>[] currentTable;
	HashEntry<K, V> nextEntry;
	HashEntry<K, V> lastReturned;

	HashIterator() {
		nextSegmentIndex = segments.length - 1;
		nextTableIndex = -1;
		advance();
	}

	/**
	 * Set nextEntry to first node of next non-empty table
	 * (in backwards order, to simplify checks).
	 */
	final void advance() {
		for (;;) {
			if (nextTableIndex >= 0) {
				if ((nextEntry = entryAt(currentTable,
										 nextTableIndex--)) != null) // 往前找到不为null的bucket
					break;
			}
			else if (nextSegmentIndex >= 0) {
				Segment<K,V> seg = segmentAt(segments, nextSegmentIndex--);// 往前找到不为null的Segment
				if (seg != null && (currentTable = seg.table) != null) 
					nextTableIndex = currentTable.length - 1;
			}
			else
				break;
		}
	}

	final HashEntry<K,V> nextEntry() {
		HashEntry<K,V> e = nextEntry;
		if (e == null)
			throw new NoSuchElementException();
		lastReturned = e; // cannot assign until after null check
		if ((nextEntry = e.next) == null)
			advance();
		return e;
	}

	public final boolean hasNext() { return nextEntry != null; }
	public final boolean hasMoreElements() { return nextEntry != null; }

	public final void remove() {
		if (lastReturned == null)
			throw new IllegalStateException();
		ConcurrentHashMap.this.remove(lastReturned.key);
		lastReturned = null;
	}
}

特性

hash特性

1）segments、Segment.table的长度均为2的幂次方；

2）用hash函数，基于key的hashCode再次哈希，对其高位、低位进一步散列 ；

3）用hash码的高位在segments中确定index，低位确定bucket index；

// 用hash码的高位在segments中确定index
int j = (hash >>> segmentShift) & segmentMask;

// 用hash码的低位确定bucket index
int index = (tab.length - 1) & hash;

ConcurrentHashMap并发设计

      其并发体现在两点：

1）Segment之间的并发；

2）Segment内部的读写并发；

Segment之间的并发

      1）并发读取segments中的元素；2）将所有操作委托给Segment。

int h = hash(key); // hash码
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;// segment index
s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)// 对segment index元素volatile读

Segment内部的读写并发

1）写线程之间竞争Segment同一把锁，读线程不加锁；
2）利用volatile、final语义保证并发写线程之间、并发读写线程之间的可见性。

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;
	if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
		(tab = s.table) != null) { // table volatile读
		for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
				 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);// table元素volatile读
			 e != null; e = e.next) { // next volatile读
			K k;
			if ((k = e.key) == key || (e.hash == h && key.equals(k))) // key、hash为final
				return e.value;// value volatile读
		}
	}
	return null;
}

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
	HashEntry<K,V> node = tryLock() ? null :
		scanAndLockForPut(key, hash, value);
	V oldValue;
	try {
		HashEntry<K,V>[] tab = table; // // table volatile读
		int index = (tab.length - 1) & hash;
		HashEntry<K,V> first = entryAt(tab, index); // table元素volatile读
		for (HashEntry<K,V> e = first;;) {
			if (e != null) {
				K k;
				if ((k = e.key) == key ||
					(e.hash == hash && key.equals(k))) {// key、hash为final
					oldValue = e.value;
					if (!onlyIfAbsent) {
						e.value = value;// value volatile写
						++modCount;
					}
					break;
				}
				e = e.next;// next volatile读
			}
			else {
				if (node != null)
					node.setNext(first);
				else
					node = new HashEntry<K,V>(hash, key, value, first);
				int c = count + 1;
				if (c > threshold && tab.length < MAXIMUM_CAPACITY)
					rehash(node);
				else
					setEntryAt(tab, index, node);// table元素volatile写，弱一致性
				++modCount;
				count = c;
				oldValue = null;
				break;
			}
		}
	} finally {
		unlock();
	}
	return oldValue;
}

segments数组的懒构造如何体现？有何作用？

      在put时，如果获取的segment为null，则进行懒构造

if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);

这样可以减少初始化内存空间。

final关键字的作用？

      final字段所在的类实例初始化完成后，在未在构造完成前暴露实例的this前提下，final字段对所有并发线程可见，可以部分减少volatile读，但是会增加初始化内存空间。