JUC源码分析-容器-ConcurrentHashMap

概述

HashMap是线程不安全的map, ConcurrentHashMap 是线程安全的map，并能适应高并发的场景。

核心属性和数据结构

final int segmentMask;

final int segmentShift;

key生成的hash值 位移segmentShift 并与上segmentMask 就是 这个key的Segment在segments数组中的索引位置。

final Segment[] segments;//存储数据的segment数组

 

ConcurrentHashMap数据由segment数组存储，每个segment都是哈希表的结构。多线程下，命中同一个Segment才会 锁排队，这样设计减少了锁竞争的几率。

 

源码分析

构造方法分析

public ConcurrentHashMap() {

this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);

}

// 默认 initialCapacity ==16，loadFactor==0.75，concurrencyLevel==16

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;// 最终 Segment数组长度

while (ssize < concurrencyLevel) {

++sshift;

ssize <<= 1;//获取 小于concurrencyLevel的 2倍数的最大值

}//concurrencyLevel的值越大 初始化的Segment数组长度越大

this.segmentShift = 32 - sshift;//sshift==4, segmentShift ==28

this.segmentMask = ssize - 1;//segmentMask ==15

//segmentShift 和segmentMask 用来计算key的Segment在segments数组中的索引位置。

//ConcurrentHashMap中key计算出的hash值是int类型的。 获取segmentShift 和segmentMask是为了 获取 hash的sshift位数值

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

int c = initialCapacity / ssize;//获取ssize的整数倍 initialCapacity==16, ssize==16,c==1

if (c * ssize < initialCapacity)

++c;

int cap = MIN_SEGMENT_TABLE_CAPACITY;//cap ==2

while (cap < c)

cap <<= 1;

// 这样搞下来 cap 是2的N次幂， cap *ssize >=initialCapacity， 不知道为啥这样搞

// create segments and segments[0]

Segment s0 = //cap==2

new Segment(loadFactor, (int)(cap * loadFactor),

(HashEntry[])new HashEntry[cap]);

Segment[] ss = (Segment[])new Segment[ssize];//ssize==16

UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]

this.segments = ss;

默认创建了一个长度为16的Segment数组。并初始化了segments[0]

}

插入节点

public V put(K key, V value) {

Segment s;

if (value == null)

throw new NullPointerException();

int hash = hash(key);

int j = (hash >>> segmentShift) & segmentMask;// 默认 获取hash高4位的值

if ((s = (Segment)UNSAFE.getObject // nonvolatile; recheck获取 j对应的Segment实例

(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment

s = ensureSegment(j);//获取不到，检查并创建一个。

return s.put(key, hash, value, false);

}

ensureSegment

//获取不到，检查并创建一个Segment，并链接到数组k位置

private Segment ensureSegment(int k) {

final Segment[] ss = this.segments;

long u = (k << SSHIFT) + SBASE; // raw offset

Segment seg;

if ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u)) == null) {//以Volatile方式检查 是否存在

//不存在 创建一个Segment并链接到数组k位置

Segment proto = ss[0]; // use segment 0 as prototype

int cap = proto.table.length;

float lf = proto.loadFactor;

int threshold = (int)(cap * lf);//使用槽位0的节点获取临界值。

HashEntry[] tab = (HashEntry[])new HashEntry[cap];//创建HashEntry数组

if ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u))

== null) { // recheck 再次检查是否在

Segment s = new Segment(lf, threshold, tab);

while ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u))

== null) { 三次检查 并处理 CAS失败

if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))

break;

}

}

}

return seg;

}

ConcurrentHashMap 的插入节点 依赖Segment的插入节点方法实现

Segment构造方法

Segment(float lf, int threshold, HashEntry[] tab) {

this.loadFactor = lf;//负载因子

this.threshold = threshold;//临界值， 节点数超过这个值要进行扩容

this.table = tab;// 存储节点的HashEntry数组

}

Segment插入节点

//主要是自旋获取锁，期间辅助寻找node位置， 如果找不到则创建node并返回。

private HashEntry scanAndLockForPut(K key, int hash, V value) {

//根据hash获取key所在槽位的第一个HashEntry

HashEntry first = entryForHash(this, hash);

HashEntry e = first;

HashEntry node = null;

//重试次数

int retries = -1; // negative while locating node

//尝试获取锁，没有获取到，开始自旋

while (!tryLock()) {

HashEntry f; // to recheck first below

if (retries < 0) {

//试着检索key对应的node，没有则创建。可能出现执行到一半，获取到了锁，终止检索。

//如果一直没有获取到锁，由于retries值的控制会一直执行，直到检索出结果

if (e == null) {//code1 涉及到无锁化算法 中的1一个步骤。

if (node == null) // speculatively create node

node = new HashEntry(hash, key, value, null);

retries = 0;

}

else if (key.equals(e.key))

retries = 0;

else

e = e.next;

}

//重试次数如果超过64次，调用重入锁lock获取锁

else if (++retries > MAX_SCAN_RETRIES) {

lock();

break;

}

//重试次数0或超过1一次且头部节点发生了改变， 设置retries，重新检索key对应的node。

else if ((retries & 1) == 0 &&

(f = entryForHash(this, hash)) != first) {

e = first = f; // re-traverse if entry changed

retries = -1;

}

}

return node;

}

code1 在实现旋获取锁的基础上，如果找不到key对应节点就创建一个，在自旋期间创建的节点为以后的执行节省了执行时间。

put方法

//在一个Segment 片段里put key-value

final V put(K key, int hash, V value, boolean onlyIfAbsent) {

HashEntry node = tryLock() ? null ://尝试获取锁 ，获取不到就自旋获取

scanAndLockForPut(key, hash, value);

//scanAndLockForPut 主要是自旋获取锁，其次如果找不到则创建node并返回。

V oldValue;

try {

HashEntry[] tab = table;

int index = (tab.length - 1) & hash;

//根据index获取key所在槽位的第一个HashEntry

HashEntry first = entryAt(tab, index);

for (HashEntry e = first;;) {

//所在槽位有HashEntry链表

if (e != null) {

K k;

//找到了key对应的node，修改原来的value

if ((k = e.key) == key ||

(e.hash == hash && key.equals(k))) {

oldValue = e.value;

if (!onlyIfAbsent) {// 允许 覆盖旧值

e.value = value;

++modCount;

}

break;//执行完修改 跳出循环 结束调用

}

//没找到继续沿着链表next查找

e = e.next;

}

//所在槽位没有HashEntry链表或槽位的链表中没有key对应的node，在链表头部插入新的节点。

else {

//在 scanAndLockForPut中创建了node，插入链表头部。

//注意：next赋值为first，说明 没有创建的node是插入链表的头部

if (node != null)

node.setNext(first);

else

//创建新的node

node = new HashEntry(hash, key, value, first);

int c = count + 1;

//节点个数超过阀值，执行rehash

if (c > threshold && tab.length < MAXIMUM_CAPACITY)

rehash(node);

else

//在Segment table上更新对应槽位上的链表

setEntryAt(tab, index, node);

++modCount;

count = c;

oldValue = null;

break;

}

}

} finally {

unlock();

}

return oldValue;

}

entryForHash和entryAt都是获取key所在槽位的第一个HashEntry，entryForHash比entryAt多了一步计算key对应记得所在槽位的index值

Segment.put()方法中如果node 不为null,证明在scanAndLockForPut中已经确定没有找到key对应节点,why在还重新查找一次？

scanAndLockForPut中确定没有找到key对应节点的时候还没有获取锁，其他线程有可能加入同样value的节点，要重新搜索

逻辑总结：

插入的节点时，先尝试加锁，不成功就自旋转获取锁， 然后计算hash值，根据hash定位所在槽位， 槽位上是个链表，从第一个节点开始向后查找。如果key对应的node已经存在， 修改原来的value结束调用，如果不存在创建key-value新节点插入链表头部。

注意 scanAndLockForPut 自旋转期间辅助创建Node， 节省后续的执行时间 是一个亮点。

 

搞明白ConcurrentHashMap的插入节点逻辑后，查询节点 就比较简单了，下面分析。

查询节点

public V get(Object key) {

Segment s; // manually integrate access methods to reduce overhead

HashEntry[] tab;

int h = hash(key);

long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;//获取key所在Segment 内存偏移值

if ((s = (Segment)UNSAFE.getObjectVolatile(segments, u)) != null &&

(tab = s.table) != null) {//获取Segment节点，并检查是否存在。

for (HashEntry e = (HashEntry) UNSAFE.getObjectVolatile

(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);

e != null; e = e.next) {//获取对应的 HashEntry ，遍历链表查找节点

K k;

if ((k = e.key) == key || (e.hash == h && key.equals(k)))

return e.value;//找到了 返回

}

}

return null;//没找到 返回 null

}

逻辑总结：

获取key对应，Segment节点，并检查是否存在，找到/获取对应的 HashEntry ，遍历链表查找节点，找到了 返回,没找到 返回 null.

 

总结：ConcurrentHashMap 依赖Segment 数组实现，理解 Segment的插入节点流程 是分析源码的重点。