文章目录
1.JAVA7与JAVA8中实现方式的区别
1.1.初始化容量方式不一样
JAVA7是在创建ConcurrentHashMap对象时候初始化容量，JAVA8是首次往ConcurrentHashMap对象中put数据时候初始化容量.
1.2.数据结构不一样
- JAVA7中采用数组加链表，增删数据采用分段锁方式，锁使用的是ReentrantLock
- JAVA8中采用数组链表加红黑树，增删数据采用CAS+synchronized方式
2.JAVA7中实现
JAVA7中一个ConcurrentHashMap实例对象是由多个分段锁对象构成的数组Segment[]实现,每个分段锁Segment由多个链表HashEntry构成的数组HashEntry[]来实现,Segment对象继承重入锁ReentrantLock,所以每次对元素操作都是对Segment对象加锁,操作完成后释放锁.
2.1.结构图
2.2.相关类图
2.3.执行流程图
2.4.源码分析
2.4.1.实例化ConcurrentHashMap对象
实例化时候会初始化为默认数量,如下:
/**
* 默认容量
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* 负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 并发级别,即同时能拿到锁的线程数也就是Segment的大小
*/
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 每个Segment中最小HashEntry数组的容量
*/
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
public ConcurrentHashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
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数组的大小
//使用大于等于concurrencyLevel的最小2幂指数作为实际并发度
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;//Segment中HashEntry数组的容量
while (cap < c)
cap <<= 1;
// 初始化首个Segment及其中HashEntry数组的容量
Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[])new HashEntry[cap]);
//初始化并发度为ssize
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
//使用unsafe类保证原子性
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
//赋值给全局变量
this.segments = ss;
}
2.4.2.赋值操作put
ConcurrentHashMap类中源码如下:
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);//通过key获取hash值
int j = (hash >>> segmentShift) & segmentMask;//通过hash值进行位运算获取标识
//判断获取到的Segment对象是否为空
if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
//如果Segment为空,则重新初始化Segment
s = ensureSegment(j);
//调用Segment对象的put进行赋值
return s.put(key, hash, value, false);
}
//重新初始化对应位置的Segment对象及其内部HashEntry数组
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;
//重新检查Segment对象是否为空
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
//使用首个Segment对象的内部数组容量与负载因子
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];
//再次检查Segment对象是否为空
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { // recheck
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
//使用cas操作赋值,直至赋值成功
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}
内部类Segment的源码:
/**
* 最大重试次数，多核处理器值为64，单核处理器值为1
*/
static final int MAX_SCAN_RETRIES = Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//尝试获取锁,直接获取成功返回链表为null,获取失败则执行scanAndLockForPut方法自旋重试,直到获取成功
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;
//如果链表中已存在此元素,则覆盖旧值
if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
//记录此key对应的值修改的次数
++modCount;
}
break;
}
e = e.next;
}
//链表中不存在key对应的元素的情况
else {
//node不为null,是首次获取锁失败,在scanAndLockForPut方法中初始化了node
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);
++modCount;//记录可以对应的值修改次数
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();//释放锁
}
return oldValue;
}
//自旋获取锁
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
//获取对应的链表HashEntry
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) // 链表为null，且当前节点为null，则创建链表且头节点为当前数据
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
else if (key.equals(e.key))
retries = 0;
else
e = e.next;
}
//重试次数大于MAX_SCAN_RETRIES则直接加锁
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
//当首次获取锁失败且链表头元素与first不相等时，重置first元素为当前链表头节点
else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
3.JAVA8中执行流程图
- JAVA8中摒弃了分段锁的机制，大量的采用CAS加Synchronized保证线程安全。
- 整体结构使用数组Node[]，其中每个数组元素Node可以是链表也可以是子类红黑树结构的TreeNode。
- 锁的粒度从对Segment加锁变为对每个数组元素Node加锁
3.1.结构图
3.2.相关类图
ConcurrentHashMap内部类太多，只介绍几个重要内部类。
3.3.执行流程图
3.4.源码分析
put操作：
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
//计算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)
tab = initTable();
//数组中无此元素，直接放入数组
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//创建node，通过cas操作将node放入数组
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//此时为扩容状态（-1）
else if ((fh = f.hash) == MOVED)
//帮助扩容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
//fh大于0为链表
if (fh >= 0) {
binCount = 1;//记录链表长度
for (Node<K,V> e = f;; ++binCount) {
K ek;
//链表中存在此元素，直接替换旧值
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;
}
}
}
//node类型为红黑树
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;
}
}
}
}
//链表长度是否为空（node类型为红黑树结构时，将binCount设置为2，也会进入此处）
if (binCount != 0) {
//链表长度大于阈值则将链表转为红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
//更新数据后，根据binCount和其他条件再次判断是否需要扩容
addCount(1L, binCount);
return null;
}
初始化数组操作：
/**
* 初始化数组
*/
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
//初始化失败，通过while死循环重新执行初始化
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;//创建数组
sc = n - (n >>> 2);//扩容阈值，即0.75*n，这种写法效率较高
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
扩容操作：
/**
* 帮助扩容
*/
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
//数组不为空，且是转发类型Node，并且新数组nextTable不为空时，尝试帮助扩容
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
//根据数据长度计算标识
int rs = resizeStamp(tab.length);
//如果数组没有被其他线程并发修改，且sizeCtl小于0（还处在扩容状态），则尝试扩容
while (nextTab == nextTable && table == tab && (sc = sizeCtl) < 0) {
//标识发生变化、扩容结束、扩容线程数达到最大，则直接退出
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//增加一个线程帮助扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
//扩容
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
/**
* 扩容
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
//计算扩容的跨度大小
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
//正常扩容时nextTab为空则先对nextTab初始化，通过helpTransfer帮助扩容时nextTab不为空
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
//将容量扩大一倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
//记录当前转移位置
transferIndex = n;
}
int nextn = nextTab.length;
//创建扩容的正在被迁移的节点
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
//bound为每次迁移的边界，i是当前的位置的索引
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//通过CAS操作，多线程时不同的线程找到的是不同的分组，可以同时对不同的分组进行扩容
else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {//扩容完成
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
//减少一个扩容线程
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//如果最后一个扩容的线程则直接退出
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit 赋值后重新进入此条件
}
}
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
//对该节点加锁，处理该节点数据
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
//找到链表节点
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;//记录最后一个节点
//找到链表中hash值不同的最后一个节点，并记录其标识，用户后面判断赋值为hn还是ln
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
//从尾部开始将元素逆序插入到对应的链表中
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
//将链表ln插入到新数组对应的i位置
setTabAt(nextTab, i, ln);
//将链表hn插入到新数组对应的i+n位置
setTabAt(nextTab, i + n, hn);
//将fwd更新入旧表中
setTabAt(tab, i, fwd);
//当前i位置迁移完成，继续迁移下一个位置
advance = true;
}
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
//如果节点数小于8，再将树转换为链表
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : (hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : (lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
4.总结
本文深入分析了ConcurrentHashMap在JAVA7和JAVA8中数据结构的变化，及对其初始化、赋值等操作的原理进行了源码分析，并对其执行流程画了流程图，两者相互对比印证能够更快速的了解其设计思想。
270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
