Java集合之ConcurrentHashMap原理解析
文章目录
通过前面学习HashMap1.7和HashMap1.8的工作原理之后可以发现HashMap存在缺点:线程不安全,可能有些猿友们会想到,那肯定是没有加锁控制才会出现线程不安全的问题,那么优化方案就是给操作HashMap的Put和GET等方法时候统一添加JDK自带的synchronized锁,而HashTable就是这么处理的。如今处于高速发展的互联网时代,并发执行效率是关注的首要话题,俗话说:技术点的更新迭代都是因为需求产生的,故此引出ConcurrentHashMap,而它确实解决了并发效率执行的问题,所以也就出现此篇猿文吧!
ConcurrentHashMap成员变量
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
/* ---------------- Constants -------------- */
// 默认初始化容量为16 (在构造方法中未引用)
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认加载因子0.75 (在构造方法中未引用)
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 默认并发等级16
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 默认最大容量为2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
// 每个segment中的最小数组容量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
// segment数组的最大值为2^16
static final int MAX_SEGMENTS = 1 << 16;
/**
* 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.
*/
static final int RETRIES_BEFORE_LOCK = 2;
// 用于计算segments下标值
final int segmentMask;
// 用于计算segments下标值
final int segmentShift;
// segments数组
final Segment<K,V>[] segments;
ConcurrentHashMap构造方法
/**
* 解读构造方法参数
* @param initialCapacity:自定义初始化容量值 默认16
* @param loadFactor : 自定义加载因子 默认0.75f
* @param concurrencyLevel: 并发等级,可以理解为同一时间段可以有concurrencyLevel个线程同时执行,若大于则需要等待锁资源,默认16
*/
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
// 校验参数(loadFactor || initialCapacity || concurrencyLevel )必须大于0
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// 并发等级最大值为2^16
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
int sshift = 0;// segments数组的偏移量
int ssize = 1;// segments数组的默认大小
while (ssize < concurrencyLevel) {
// 若concurrencyLevel为默认值16,则ssize =16 sshift=4 break循环
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;// 28
this.segmentMask = ssize - 1;//15
// 判断初始化容量值是否大于最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;// c= 16/16=1
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;//每个segment下的table最小容量大小=2
while (cap < c)
cap <<= 1;
// 创建segments[0],而S0下的table数组大小为2,等后面需要时再进行创建
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
// 创建segments 数组 ,容量大小为ssize=16,具体的大小由ssize决定
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
// 通过Unsafe将S0存入segments 数组中
// TODO 此处需要了解下Unsafe(并发操作类)
UNSAFE.putOrderedObject(ss, SBASE, s0);
// 将数组ss指向segments
this.segments = ss;
}
Segment构造方法
/**
* 根据类关系可以发现单个Segment类继承自ReentrantLock ,而ReentrantLock 是juc下支持并发编程操作的一个类
* 同时可以发现,每个Segment都包含了自己的table数组,且Segment仅控制自己的table数组,而Segments数组锁与锁之前分开互不影响,也被称为分段锁。
*/
static final class Segment<K,V> extends ReentrantLock implements Serializable {
// 自旋锁的最大次数
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
// Segment下的table数组 且被volatile关键字修饰
transient volatile HashEntry<K,V>[] table;
// 用于统计元素的个数 类似于HashMap的size方法
transient int count;
// 操作当前segment的次数
transient int modCount;
// table待扩容阈值(int)(capacity * loadFactor).)
transient int threshold;
// 加载因子 默认和segments保持一致
final float loadFactor;
// 构造方法
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
// TODO 继续阅读代码可以发现 Segment 重写了Put和get等方法。
....
}
Put方法
public V put(K key, V value) {
// 定义一个segment
Segment<K,V> s;
// 不允许value 为空
if (value == null)
throw new NullPointerException();
// 根据key获取hashcode值
int hash = hash(key);
// 获取segments数组的下标index=(hash >>> segmentShift) & segmentMask
int j = (hash >>> segmentShift) & segmentMask;
//当前segment为空,需要创建一个segment,进入ensureSegment方法
if ((s = (Segment<K,V>)UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null)
s = ensureSegment(j);
// 调用segment的put方法
return s.put(key, hash, value, false);
}
ensureSegment方法
/**
* 获取一个Segment对象,由于此处没有加锁控制,因此多次通过Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null进行判断,来保证segments数组中下标index仅创建唯一一个Segment
*/
private Segment<K,V> ensureSegment(int k) {
// segments数组指向ss
final Segment<K,V>[] ss = this.segments;
// 计算偏移量值 u
long u = (k << SSHIFT) + SBASE;
Segment<K,V> seg;
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
// 为空表示下标index的Segment对象仍为空
// 取ss[0]的相关配置信息,即就是后面创建的Segment配置均以ss[0]为准则
Segment<K,V> proto = ss[0];
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) {
// recheck ,为空表示下标index的Segment对象仍为空
// 创建一个Segment
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
// 采用自旋的方式 再次对segment判断是否为空
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) {
// 使用unsafe的CSA完成ss数组的元素添加 确保独一份 ,随后break终止while循环
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
// 返回segment对象 (可能由任意一个线程产生,返回即可)
return seg;
}
Segment下的Put方法
/**
* lock():如果锁被另一个线程持有,那么当前线程出于线程调度的目的将被禁用,并处于休眠状态,直到获得锁,此时锁持有计数被设置为1。
* tryLock():如果当前线程已经持有该锁,则保持计数加1,方法返回true。
如果锁被另一个线程持有,则此方法将立即返回值为false
* 以上二者区别:tryLock可以尝试获取锁,而不会让其他线程处于休眠状态,即就是在获取不到锁的情况下可以试着做些其他事情scanAndLockForPut()方法。
*/
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 使用tryLock方法获取锁
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
/**
* 表示获取到lock锁 逻辑与HashMap的Put方法逻辑一致,如以下三步:
* 1、获取下标index
* 2、获取下标index位置对应的头结点HashEntry
* 3、循环遍历链表元素(元素是否存在-> 不存在添加新节点HashEntry,若存在则返回oldValue,再就是数组扩容等逻辑)
*/
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;
++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);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
// 释放锁
unlock();
}
return oldValue;
}
scanAndLockForPut方法
/**
* 此处逻辑相当于 在获取不到锁的情况下,尝试做一些可以做的其他准备工作
*/
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
// 获取头结点first
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
int retries = -1; // 统计线程自旋的次数
// 以下是采用自旋的方式来获取lock锁
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) {
// retries最多尝试64次 之后该线程会再次获取lock锁,如果再获取不到,则会处于阻塞中(即就是线程阻塞中), 随后break 退出循环
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
// 因为jdk1.7在插入的时候采用的是头插法,故此处比较头结点是否跟first是否一致,如果不相等,则表示链表被调整了
e = first = f; //将节点e和first赋值为最新头节点f
retries = -1;// retries 置为-1 重新自旋
}
}
// 返回node节点
return node;
}
Get方法
public V get(Object key) {
Segment<K,V> s; // segment对象
HashEntry<K,V>[] tab;
int h = hash(key);//获取hashcode
// 根据hashcode、segment偏移量以及segment掩码来获取segments数组下标
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
// 如果数组不为空且segment也不为空,且segment的table数组也不为空,则说明元素存在,需要进行遍历segment的table数组下的链表元素
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;
// 如果key相等或(hashcode相等且key也相等)时,返回value值
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
// 返回null
return null;
}
小结
如上分析可以得到,ConcurrentHashMap是不允许value值为空的,但是key是可以为空,区别于HashMap是Key和value均可以为空,数据存储结构仍为数组+链表的形式,那么ConcurrentHashMap是如何避免线程安全问题呢?如下分析:
- 1、采用分段锁的思想进行分段控制(Segments),Segment继承自ReentrantLock,并且在Segment内部 重写了put和get方法,不过大概逻辑是在添加元素时增加了lock和unlock。
- 2、Segment包含了自身的table属性,多个Segment之间操作互不影响。
以上就是我对ConcurrentHashMap和HashMap区别的理解,不过吸引我的是jdk1.8对于ConcurrentHashMap的调整,因为毕竟数据结构发生了改变,引入了红黑树,我的好奇心是对于数组扩容和数据转移方面jdk1.8又会是怎么处理的呢,那么下一篇文章就以此为引吧!!! 下次见哦。