文章目录
- 一、常见属性
- 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等于16this(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_SEGMENTSif (concurrencyLevel > MAX_SEGMENTS)concurrencyLevel = MAX_SEGMENTS;// Find power-of-two sizes best matching argumentsint sshift = 0;int ssize = 1;//当concurrencyLevel等于16，sshift=4 2^4 = 16while (ssize < concurrencyLevel) {++sshift;//左移乘2，找到里2的次幂最近的数ssize <<= 1;}//int类型32个bit位 32-4 = 28 put方法会用到，先这么理解this.segmentShift = 32 - sshift;//这里表示segment长度-1this.segmentMask = ssize - 1;//判断初始容量是否超过最大值if (initialCapacity > MAXIMUM_CAPACITY)//将initialCapacity 设置为最大容量initialCapacity = MAXIMUM_CAPACITY;//如果initialCapacity 和ssize走默认值 16 , c = 1int 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 offsetSegment<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,否则调用scanAndLockForPutHashEntry<K,V> node = tryLock() ? null :scanAndLockForPut(key, hash, value);V oldValue;try {//获取segment内部的tableHashEntry<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的情况，采用头插法，创建一个新的nodenode = new HashEntry<K,V>(hash, key, value, first);//当前segment内部存放的元素+1int 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 belowif (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//如果发生了变化，重新设置为-1retries = -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);//创建一个新的tableHashEntry<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不等于nullHashEntry<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 nodesfor (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 overheadHashEntry<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是一个高效的线程安全哈希表实现，适用于并发访问的场景，但需要注意它的一些限制和特性。
