Jdk1.7之ConcurrentHashMap源码总结

news/2024/10/22 13:51:39/

文章目录

  • 一、常见属性
    • 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. 缺点

ConcurrentHashMap

一、常见属性

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;
}

ConcurrentHashMap

图1.1

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是一个高效的线程安全哈希表实现，适用于并发访问的场景，但需要注意它的一些限制和特性。


http://www.ppmy.cn/news/1099097.html

相关文章

CentOS 7 调优之周期性的访问中断

CentOS 7 调优之周期性的访问中断

文章目录 背景问题描述原因分析解决方案相关版本 背景 操作系统版本&#xff1a;CentOS Linux release 7.6.1810 (Core) 操作系统镜像安装后&#xff0c;未进行任何调整。正常部署应用&#xff0c;应用在 CentOS 7.9 未出现过此类现象。 问题描述 问题描述&#xff1a;负载教…
阅读更多...
软件源码开发，网络中的“摄像头”：运维监控系统

软件源码开发，网络中的“摄像头”：运维监控系统

在日常生活中&#xff0c;我们不管是在大街小巷&#xff0c;还是在商场大厦都可以见到一个圆形或是方形带有镜片的“小盒子”&#xff0c;这个“小盒子”就是摄像头&#xff0c;摄像头作为一个能实时录制记录它能照到范围内的视频图像的工具&#xff0c;可以在丢失物品、抓捕坏…
阅读更多...
jenkins如何请求http接口及乱码问题解决

jenkins如何请求http接口及乱码问题解决

文章目录 1.插件安装2.请求pipline语法3.插件方式实现4.乱码问题解决5.值得注意 1.插件安装 需要安装HTTP Request 插件&#xff1b;安装方式不介绍。 2.请求pipline语法 官网链接&#xff0c;上面有详细语法&#xff1a;https://plugins.jenkins.io/http_request/ 附一个d…
阅读更多...
线程的状态 and 线程安全

线程的状态 and 线程安全

在操作系统中的线程&#xff0c;自身是有一个状态的~&#xff0c;但是Java Thread是对系统线程的封装&#xff0c;把这里的状态又进一步精细化了。 1.NEW 系统中的线程还没创建出来呢&#xff01;只是有一个Thread对象~ public class Main1 {public static void main(String[…
阅读更多...
003微信小程序云开发API数据库-新增集合-删除集合-获取集合信息

003微信小程序云开发API数据库-新增集合-删除集合-获取集合信息

文章目录 1.微信小程序云开发API数据库-新增集合案例代码 2.微信小程序云开发API数据库-删除集合案例代码 3.微信小程序云开发API数据库-获取集合信息案例代码 1.微信小程序云开发API数据库-新增集合 微信小程序云开发API数据库是一个方便快捷的数据库解决方案&#xff0c;可以…
阅读更多...
【漏洞复现】Tenda路由器存在密码泄露

【漏洞复现】Tenda路由器存在密码泄露

漏洞描述 腾达W15E路由器外置4根增强型360全向天线&#xff0c;苛刻调校到0.01毫米级的零干扰间距&#xff0c;科学独立布局的信号放大器PA&#xff0c;穿墙性能更强劲&#xff0c;覆盖范围更广&#xff0c;在哪都有好信号。 该型号的路由器系统存在密码泄露漏洞&#xff0c;…
阅读更多...
python3 简易 http server：实现本地与远程服务器传大文件

python3 简易 http server：实现本地与远程服务器传大文件

在个人目录下创建新文件httpserver.py &#xff1a; vim httpserver.py文件内容为python3代码&#xff1a; # !/usr/bin/env python3 import datetime import email import html import http.server import io import mimetypes import os import posixpath import re import…
阅读更多...
通过 http-server 运行刚打包出来的脚手架项目

通过 http-server 运行刚打包出来的脚手架项目

这里 我打包了自己的vue项目 react其实也一样 如果我直接 打开打包出来的 dist 下面的index.html 会出现白屏资源找不到 或者跨域等问题 这个问题其实配个nginx也能解决 但是其实如果只是想做个测试 nginx就太麻烦了 我们可以通过npm指令 全局安装一个http-server 终端执行 …
阅读更多...
最新文章

Copyright @ 2022~2023