JDK 1.7
数据结构
JDK 1.7 结构
Segment 分段锁
依旧是数组+链表，Segment 是一个 ReentrantLock 可重入锁：
static final class Segment<K,V> extends ReentrantLock implements Serializable
数据操作的时候，先定位到 Segment 数组的位置，然后尝试获取锁。某个线程获取锁成功就进行数据添加、移除等操作，这时其它线程需要操作数据，会进入 Segment 的锁队列（AQS）并根据情况进入阻塞状态。等待独占线程释放锁后，后面的线程接着进行数据操作。
每一个 Segment 都是一个锁，各个锁之间互不影响。也就是当 Segment A 被某线程操作数据的时候，Segment B 依旧可以进行数据操作，这就是所谓 “锁分离” 的大概原理。这样分段锁的效率要高于整个数据加锁、也高于 synchronized 对方法加锁。
元素个体 HashEntry
HashEntry 数组是真正存放数据的地方：
static final class HashEntry<K,V> {
final int hash; // hash值
final K key; // key
volatile V value; // 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;
}
}
要注意的是 value 和 next 结点都是 volatile 修饰的，保证了其可见性，也就是在读取的时候都是最新的值。
构造器
/**
* 默认的初始容量 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* 默认的负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 默认的并发数量,会影响segments数组的长度(初始化后不能修改)
*/
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 最大容量,构造ConcurrentHashMap时指定的值超过,就用该值替换
* ConcurrentHashMap大小必须是2^n,且小于等于2^30
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 允许最大segment数量,用于限定concurrencyLevel的边界,必须是2^n
*/
static final int MAX_SEGMENTS = 1 << 16;
/**
* 非锁定情况下调用size和contains方法的重试次数,避免由于table连续被修改导致无限重试
*/
static final int RETRIES_BEFORE_LOCK = 2;
/**
* segments数组
*/
final Segment<K,V>[] segments;
构造器可指定默认初始容量，增长因子，并发等级（决定同一时间允许线程操作的数据）。
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// MAX_SEGMENTS 为最大 Segment 数量，默认 1<<16=65536
// 如果超过了最大容量，直接设置为最大
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// 找到距离并发数最大的 2 的幂数，作为 Segment 数组的容量
int sshift = 0;
int ssize = 1;
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// 根据传来的参数，创建 Segment 模板 s0
// 放置元素时需要初始化 Segment，需要用到这个模板
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;
}
数据存放
public V put(K key, V value) {
Segment<K,V> s;
// value 不可为 null
if (value == null)
throw new NullPointerException();
// key 不可为 null，否则 hashCode 方法空指针
int hash = hash(key.hashCode());
// hash 码进行运算，相当于扰动一下
int j = (hash >>> segmentShift) & segmentMask;
// 根据 hash 值获取对应的 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);
}
ConcurrentHashMap 键值不可为 null。至于为什么这么设计，有一种说法是为了避免多线程下获取数据，无法区分到底是没有该数据，还是该数据为 null 的情况。
定位 Segment 位置，如果不存在则创建 Segment。
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;
// & 运算获取下标，类似取模但是效率高于取模
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
// 遍历链表
for (HashEntry<K,V> e = first;;) {
if (e != null) { // 链表结点不为空
K k;
// 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 {// 链表头结点为空
// 不为 null
if (node != null)
// 将新结点放进链表首位，调用 putOrderedObject 进行内存地址偏移确定位置
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
// 头结点放在下标处，会调用 putOrderedObject 确定位置
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
// 最后释放锁
unlock();
}
return oldValue;
}
- 某个线程来到该方法，首先尝试获取锁。获取成功执行后续 put 操作，失败进行自旋尝试获取。如果重试次数最大则进入 AQS 队列，再根据其状态进行阻塞或中断等待获取。
scanAndLockForPut 再次尝试获取锁或阻塞。
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();// 进入 ReetLock 的 lock 方法，会进行排队或阻塞
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
- 根据 hash 计算出下标，根据下标定位 HashEntry 数组的位置，新增的元素即将插入该位置并作为头结点。
- 紧接着遍历链表，如果新元素下标与已存在的相同，则覆盖值并退出循环。
- 遍历出现 null 的情况，要么是空桶、要么是遍历完了链表。然后将新增的元素添加到链表首位，UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e) 相当于把数据存放到合适的地址中去。
确定容量
每个 Segment 进行数据存放或删除时，会统计 modCount（编辑次数）和 count（元素数量）。
计算 size 时，进行三次遍历。如果最后两次的 modCount 相同说明近期没有发生数据变化，可以乐观的认为计算出的 count 就是最终数量。
如果最后两次统计的 modCount 不一致，说明近期数据可能发生了变化。只能把每个 Segment 锁住，然后计算它们的容量返回结果，最后释放锁。这个过程就挺悲观的了。
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;
final int segmentCount = segments.length;
long previousSum = 0L;
for (int retries = -1; retries < RETRIES_BEFORE_LOCK; retries++) {
long sum = 0L; // sum of modCounts
long size = 0L;
for (int i = 0; i < segmentCount; i++) {
Segment<K,V> segment = segmentAt(segments, i);
if (segment != null) {
sum += segment.modCount;
size += segment.count;
}
}
if (sum == previousSum)
return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
previousSum = sum;
}
long size = 0L;
for (int i = 0; i < segmentCount; i++) {
Segment<K,V> segment = ensureSegment(i);
segment.lock();
size += segment.count;
}
for (int i = 0; i < segmentCount; i++)
segments[i].unlock();
return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
}
扩容机制 rehash
当数组容量到达一定值(threshold)时，进行扩容。
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
threshold = 数组容量*增长因子。
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length; // 旧数组长度
int newCapacity = oldCapacity << 1; // 翻倍
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; // 根据 hash 和新的掩码生成下标
if (next == null) // 只有一个元素的链表，直接放就好
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;
// 如果 p==lastRun 说明所有元素下标都未发生变化，也就不需要遍历了
// 反之，把发生变化的链表位置重新归置一下
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;
}
因为扩容之前已经进行了加锁处理，所以无需考虑同步问题。
get 获取元素
get 的过程是不加锁的，效率较高。首先根据 hash 值定位到 Segment 位置，然后再进行链表的遍历直到搜索到元素即可。
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key.hashCode());
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) {
// 弱一致性的的原因，遍历时该 Segment 可能已经更新
// contains 方法也有同样的问题
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
为什么 get 过程不加锁，首先获取 Segment 的时使用的 UNSAFE.getObjectVolatile 方法，进行 volatile语义的读取。volatile 读取保证了该 Segment 在读取时是最新的，但是在遍历的时候，原 Segment 可能已经发生了变化，在使用时需要注意。
remove 移除元素
同样是先找到相应的 Segment，然后加锁进行移除，移除完毕释放锁。
public V remove(Object key) {
int hash = hash(key.hashCode());
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);
else
pred.setNext(next);
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
unlock();
}
return oldValue;
}
JDK 1.8
数据结构
不再采用多个 Segment 结构，而是 Node 数组+链表/红黑树来存储数据。这样做优化了查询速度，由原来的链表查询 O(n) 优化为红黑树 O(logn)。
JDK 1.8 数据结构
元素个体：Node<K,V>
Node 结点的值 val 和 下一个结点 Node 都是 volatile 修饰的，保证了可见性（保证读取时是最新的）。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
public final String toString() {
return Helpers.mapEntryToString(key, val);
}
...
构造器
构造器之一，参数最多就贴出来。
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
- initialCapacity：指定初始容量，默认的是 16。需要注意的是当初始容量小于并发数量，会直接等于并发数。
- loadFactor：指定阈值，当容量大于该值进行扩容。
- concurrencyLevel：并发数。
数据存放
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 不可为 null
if (key == null || value == null) throw new NullPointerException();
// 1. hash 值处理
int hash = spread(key.hashCode());
int binCount = 0;
// 遍历
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
2. 初始化
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// volaite 读取，要插入的位置为 null 说明当前下标没有数据，可创建头结点
// CAS 插入数据，期望值 null 要修改的值新 Node
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 3. 正在扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 4. volatile 只保证了 Node 值和下一个结点的可见性，并不保证原子性
// 所以需要加锁
synchronized (f) {
// 找到结点下标位置
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
// 遍历这串链表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// key 相同，覆盖 value
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
// 尾插法
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
// 添加树节点
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
else if (f instanceof ReservationNode)
throw new IllegalStateException("Recursive update");
}
}
if (binCount != 0) {
// 超过 8 个转换为红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 5. 容量计算
addCount(1L, binCount);
return null;
}
- spread 方法先进行高 16 位与低 16 位进行异或，进行扰动。然后再和 HASH_BITS 进行 & 运算，也就是与 0111 1111X7 进行 & 运算，保证 hash 值不为负数顺便又进行一次扰动。
因为负数定位了一些数据正在参与扩容、树节点转换、反转等信息，避免冲突。
static final int HASH_BITS = 0x7fffffff;
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
- table 为空的初始化，经典的 自旋+CAS。如果有线程正在初始化，则 CAS 标记一个数值表示正在初始化。当别的线程进来时，发现正在初始化，则 yield 让出 CPU。下次再进入自旋循环时，可能已经初始化完毕，进行后面的 put 操作了。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0) // 小于 0 说明可能正在初始化中，转换为就绪状态，让出 cpu
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {// CAS 一下，期望值 sc，要修改的值 -1。保证其它线程来到这里时不会影响正常初始化
try {
if ((tab = table) == null || tab.length == 0) {
// 默认 16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// 减去除以 4，相当于 %75
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
如果 hash 值为 MOVE，说明正在扩容
结点加同步，之后无非就是进行遍历。查询新插入的 key 是否重复，如果重复覆盖值。
容量计算，ConCurrentHashMap 使用一个 volatile 的 baseCount 来表示当前修改过后元素的个数。
private transient volatile long baseCount;
容量计算
ConCurrentHashMap 使用 CounterCells[] 数组和 baseCount 来存放和计算容量：
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
// 初始容量和遍历 CounterCell 数组存储的数量
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
CounterCells 对象包含一个数量属性，CounterCells 数组所有元素的数量属性加起来再加上 ConCurrentHashMap 的 baseCount 就是容量了。
CounterCells 初始化时默认容量是 2。当一个线程添加数据时，首先生成线程的哈希指针（相当于随机数，但是比 Radom 性能要好），然后将哈希指针和 CounterCells 容量-1 进行 & 运算。这与 HashMap 确认下标的过程类似，然后将创建 CounterCells 对象设置容量，再赋值到 CounterCells 数组中。
扩容机制
扩容条件：当前容量超过阈值。
transfer 当容量不足时进行扩容。这块内容比较复杂，暂时略过。
private final void addCount(long x, int check) {
...
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// s 是计算出的元素数量，超过阈值 sizeCtl 触发扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
get 获取元素
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
get 比较简单，先确认 hash 桶的位置，然后遍历直到找到并返回 value 为止。找不到返回 null。
这个过程无需加锁，效率较高。因为 Node 结点的 value 是 volatile 修饰的，保证了读取的可见性。
