文章目录
- 一、常见属性
- 1. 初始化容量
- 2. 加载因子
- 3. 并发级别
- 二、重要方法
- 1. 构造方法
- 2. ConcurrentHashMap#put方法
- 2.1 ConcurrentHashMap#put#ensureSegment
- 2.2 ConcurrentHashMap#Segment#put
- 2.2.1 Segment#put#scanAndLockForPut
- 2.2.2 Segment#put#rehash
- 3. ConcurrentHashMap#get方法
- 三、总结
- 1. 优点
- 2. 缺点
一、常见属性
1. 初始化容量
/**
* The default initial capacity for this table,
* used when not otherwise specified in a constructor.
*/
//默认初始化的容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
2. 加载因子
/**
* The default load factor for this table, used when not
* otherwise specified in a constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
3. 并发级别
/**
* The default concurrency level for this table, used when not
* otherwise specified in a constructor.
*/
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
二、重要方法
1. 构造方法
public ConcurrentHashMap() {
//见图1.1 如果DEFAULT_INITIAL_CAPACITY等于32 DEFAULT_CONCURRENCY_LEVEL等于16
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();
//如果concurrencyLevel 大于最大支持的并发量，则设置为MAX_SEGMENTS
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
//当concurrencyLevel等于16，sshift=4 2^4 = 16
while (ssize < concurrencyLevel) {
++sshift;
//左移乘2，找到里2的次幂最近的数
ssize <<= 1;
}
//int类型32个bit位 32-4 = 28 put方法会用到，先这么理解
this.segmentShift = 32 - sshift;
//这里表示segment长度-1
this.segmentMask = ssize - 1;
//判断初始容量是否超过最大值
if (initialCapacity > MAXIMUM_CAPACITY)
//将initialCapacity 设置为最大容量
initialCapacity = MAXIMUM_CAPACITY;
//如果initialCapacity 和ssize走默认值 16 , c = 1
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
//c要向上取整
++c;
//cap = 2 代表segment数组容量
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
//创建一个segment对象，设置阈值cap * loadFactor
//扩容是针对segment里的hashEntry扩容，并不是整个segment都要扩容
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
//创建一个空的segment数组，这里ssize一定是2的次幂
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
//使用CAS将创建出来的s0对象放到第0个位置，这里是为了复用segment对象，因为每个segment在首次创建时（初始化）属性都一样，后续扩容就是自己内部segment的事情了
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
2. ConcurrentHashMap#put方法
public V put(K key, V value) {
Segment<K,V> s;
//value等于null抛异常
if (value == null)
throw new NullPointerException();
//根据key算出一个hash值
int hash = hash(key);
//segmentMask其实就是segment数组的大小-1，可以看下构造方法哪里
//算出落在Segment数组中的位置 j
//segmentShift默认计算出是28，可以看下构造方法哪里
//int类型hash值右移28位，相当于保留了高4位 再进行&操作
//（segmentMask可以推出15由构造方法）而15二进制低4位是1,高4位与低4位相互对应，合理算出segment下标
int j = (hash >>> segmentShift) & segmentMask;
//如果对应segment数组中的segment对象等于null,还没有初始化，则生成一个segment对象
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
//生成一个segment对象
s = ensureSegment(j);
//调用segment对象的put方法
return s.put(key, hash, value, false);
}
🐱🚀这里需要注意ConcurrentHashMap的key不能为null，但是hashmap是可以为null的。🐱🚀
2.1 ConcurrentHashMap#put#ensureSegment
private Segment<K,V> ensureSegment(int k) {
//获取segment数组
final Segment<K,V>[] ss = this.segments;
long u = (k << SSHIFT) + SBASE; // raw offset
Segment<K,V> seg;
//这里多线程如果落到同一个下标，会产生竞争，所以需要进行一下判空
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
//获取segment数组的第0个位置，与构造方法哪里进行对应 复用
Segment<K,V> proto = ss[0]; // use segment 0 as prototype
//获取第0个位置segment内部HashEntry数组大小
int cap = proto.table.length;
float lf = proto.loadFactor;
int threshold = (int)(cap * lf);
//创建segment内部的HashEntry数组，注意cap与第0个segment保持一直
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
//类似double check 再次判断
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck
//真正的创建一个Segment对象，此时还没有放到Segment数组中,只是创建
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
//死循环+CAS保证刚创建的Segment对象成功放到segment数组中
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) {
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
//操作成功，返回
break;
}
}
}
return seg;
}
2.2 ConcurrentHashMap#Segment#put
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//c尝试获取一把独占锁，因为segment继承ReentrantLock
//获取到锁返回null,否则调用scanAndLockForPut
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
//获取segment内部的table
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))) {
//如果存在key相同的
oldValue = e.value;
if (!onlyIfAbsent) {
//不存在才更新
e.value = value;
++modCount;
}
break;
}
//当遍历到链表的最后一个元素，这里e = null,因为这里是死循环，所以会走到else分支
e = e.next;
}
else {
//
if (node != null)
node.setNext(first);
else
//对应链表上没有key,value的情况，采用头插法，创建一个新的node
node = new HashEntry<K,V>(hash, key, value, first);
//当前segment内部存放的元素+1
int c = count + 1;
//大于阈值，则rehash进行扩容，该方法是segment对象自己的，所以是内部扩容
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//segment内部进行扩容
rehash(node);
else
//CAS尝试放到数组的第i个位置
setEntryAt(tab, index, node);
++modCount;
//对count赋值
count = c;
oldValue = null;
break;
}
}
} finally {
//解锁
unlock();
}
//返回旧值
return oldValue;
}
2.2.1 Segment#put#scanAndLockForPut
//继续尝试获取锁过程中，提前构建HashEntry对象
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
//this代表当前segment对象
//获取hash值对应下标的元素
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) { retries = -1
//一开始会进到这个分支
if (e == null) {
if (node == null) // speculatively create node
//创建一个node结点
node = new HashEntry<K,V>(hash, key, value, null);
//将retries 置为0，下次循环就不会进到该分支了
retries = 0;
}
else if (key.equals(e.key))
//如果发现有相同的key，就不用创建node节点了
//将retries 置为0，下次循环就不会进到该分支了
retries = 0;
else
//遍历链表，直到尾结点
e = e.next;
}
//避免CPU过度消耗，达到一定重试次数后，直接阻塞式获取锁
else if (++retries > MAX_SCAN_RETRIES) {
lock();
//获取到锁，则break退出循环
break;
}
//retries 为偶数的情况下 并且 查看当前线程获取锁过程中链表头结点是否发生了改变
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
//如果发生了变化，重新设置为-1
retries = -1;
}
}
return node;
}
2.2.2 Segment#put#rehash
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
//左移一位，成倍扩容
int newCapacity = oldCapacity << 1;
//重新计算阈值
threshold = (int)(newCapacity * loadFactor);
//创建一个新的table
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) {
//定义next指向
HashEntry<K,V> next = e.next;
//算出新数组的下标
int idx = e.hash & sizeMask;
if (next == null) // Single node on list
//如果next为null,说明只有一个元素，直接转移
newTable[idx] = e;
else { // Reuse consecutive sequence at same slot
//如果next不等于null
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;
// 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;
}
3. ConcurrentHashMap#get方法
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;
//从segment数组中获取下标对应Segment对象
//UNSAFE操作获取内存里最新的对象，而不是Cpu缓存里面的
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是Java中的一个线程安全的哈希表实现，它在多线程环境下提供了高效的并发访问。
1. 优点
它的优点包括：
-
1、线程安全：ConcurrentHashMap使用锁分段技术来实现线程安全，它将哈希表分成多个段，每个段拥有自己的锁，不同的线程可以同时访问不同的段，从而提高了并发性能。
-
2、高效性能：ConcurrentHashMap在并发环境下提供了较好的性能，读操作不需要加锁，写操作只需要锁定特定的段，而不是整个哈希表，从而减少了锁的竞争。
-
3、高效的迭代：ConcurrentHashMap的迭代器支持弱一致性，即在迭代期间，如果其他线程对哈希表进行修改，迭代器会继续返回旧的数据，而不会抛出ConcurrentModificationException异常。
-
4、增强的功能：ConcurrentHashMap提供了一些额外的功能，例如atomic putIfAbsent、replace和remove等方法，这些方法在并发环境下可以原子地执行操作。
2. 缺点
然而，ConcurrentHashMap也有一些缺点：
-
1、内存消耗较大：由于ConcurrentHashMap需要维护额外的线程安全机制，它的内存消耗比普通的HashMap要大。
-
2、有限的一致性：尽管ConcurrentHashMap提供了较好的并发性能，但它的一致性是弱一致性，即在并发修改的情况下，不能保证读取到最新的数据。
-
3、不支持空键和空值：ConcurrentHashMap不允许使用null作为键或值，如果需要使用null，可以使用特殊值来代替。
总体而言，ConcurrentHashMap是一个高效的线程安全哈希表实现，适用于并发访问的场景，但需要注意它的一些限制和特性。
![[学习笔记]DeepWalk图神经网络论文精读](https://img-blog.csdnimg.cn/95ff673399934b85b341c704794d8e45.png)
