ConcurrentHashMap 1

volatile V value; //存入的值

volatile HashEntry<K,V> next; //记录下一个元素，形成单向链表

HashEntry(int hash, K key, V value, HashEntry<K,V> next) {

this.hash = hash;

this.key = key;

this.value = value;

this.next = next;

}

}

2、添加元素

1.1、ConcurrentHashMap的put方法

public V put(K key, V value) {

Segment<K,V> s;

if (value == null)

throw new NullPointerException();

//基于key，计算hash值

int hash = hash(key);

//因为一个键要计算两个数组的索引，为了避免冲突，这里取高位计算Segment[]的索引

int j = (hash >>> segmentShift) & segmentMask;

// 此处是重点：我们的hash值的高位 & segment 长度 - 1 得到在segment数组中的位置

// 我们的hash值得低位 & segment 长度 - 1

//判断该索引位的Segment对象是否创建，没有就创建

if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null)

s = ensureSegment(j); // 创建segment对象

return s.put(key, hash, value, false); //调用Segmetn的put方法实现元素添加

}

1.2、ConcurrentHashMap的ensureSegment方法

//创建对应索引位的Segment对象，并返回

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;

//获取，如果为null，即创建

if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) { //再次确认，segment槽是否为null

//以0角标位的Segment为模板

Segment<K,V> proto = ss[0]; // 从segment[0] 这个位置拷贝信息

int cap = proto.table.length; // HashEntry数组的长度

float lf = proto.loadFactor; //加载因子

int threshold = (int)(cap * lf); //扩容阈值

HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap]; //创建hashentry

//到此一个segment对象需要的参数准备好了！

//获取，如果为null，即创建

if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))== null) { //再次确认，segment槽是否为null

Segment<K,V> s = new Segment<K,V>(lf, threshold, tab); //在此处创建Segnment对象！

//自旋方式，将创建的Segment对象放到Segment[]中，确保线程安全

while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))== null) {

if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s //cas操作！保证线程安全

break;

}

}

}

//返回

return seg;

}

1.3、Segment的put方法

final V put(K key, int hash, V value, boolean onlyIfAbsent) {

//尝试获取锁，获取成功，node为null，代码向下执行

//如果有其他线程占据锁对象，那么去做别的事情，而不是一直等待，提升效率 （自选等待的过程中，做一些什么？完成对象的创建）

HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);//scanAndLockForPut 稍后分析

V oldValue;

try {

HashEntry<K,V>[] tab = table;

//取hash的低位，计算HashEntry[]的索引

int index = (tab.length - 1) & hash; //hash的低位 & HashEntry[]数组长度 - 1 得到在HashEntry的位置

HashEntry<K,V> first = entryAt(tab, index); //获取索引位的元素对象first

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 { //如果获取到的元素为空

//当前添加的键值对的HashEntry对象已经创建

if (node != null)

node.setNext(first); //头插法关联即可

else

//创建当前添加的键值对的HashEntry对象

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;

}

1.4、Segment的scanAndLockForPut方法

该方法在线程没有获取到锁的情况下，去完成HashEntry对象的创建，提升效率

但是这个操作个人感觉有点累赘了。

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {

//获取头部元素

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) {

//没有下一个节点，并且也不是重复元素，创建HashEntry对象，不再遍历

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))

//重复元素，不创建HashEntry对象，不再遍历

retries = 0;

else

//继续遍历下一个节点

e = e.next;

}

else if (++retries > MAX_SCAN_RETRIES) {

//如果尝试获取锁的次数过多，直接阻塞

//MAX_SCAN_RETRIES会根据可用cpu核数来确定

lock();

break;

}

else if ((retries & 1) == 0 &&

(f = entryForHash(this, hash)) != first) {

//如果期间有别的线程获取锁，重新遍历

e = first = f; // re-traverse if entry changed

retries = -1;

}

}

return node;

}

图解 ：

到此向ConcurrentHashMap当中插入一个键值对的操作就完成了！

3、扩容机制

private void rehash(HashEntry<K,V> node) {

HashEntry<K,V>[] oldTable = table;

int oldCapacity = oldTable.length;

//两倍容量

int newCapacity = oldCapacity << 1;

threshold = (int)(newCapacity * loadFactor);

//基于新容量，创建HashEntry数组

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) {

HashEntry<K,V> next = e.next;

int idx = e.hash & sizeMask;

if (next == null) // Single node on list

//原位置只有一个元素，直接放到新数组即可

newTable[idx] = e;

else { // Reuse consecutive sequence at same slot

//=图一=============

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

//这里旧的HashEntry不会放到新数组

//而是基于原来的数据创建了一个新的HashEntry对象，放入新数组

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;

}

图解

图1

图2

图3

4、获取集合长度

size()

public int size() {

// Try a few times to get accurate count. On failure due to

// continuous async changes in table, resort to locking.

final Segment<K,V>[] segments = this.segments;

int size;

boolean overflow; // true if size overflows 32 bits

long sum; // sum of modCounts

long last = 0L; // previous sum

int retries = -1; // first iteration isn’t retry

try {

for (;😉 {

//当第5次走到这个地方时，会将整个Segment[]的所有Segment对象锁住

if (retries++ == RETRIES_BEFORE_LOCK) {

for (int j = 0; j < segments.length; ++j)

ensureSegment(j).lock(); // force creation

}

//以下部分会执行5次

sum = 0L;

size = 0;

overflow = false;

for (int j = 0; j < segments.length; ++j) {

Segment<K,V> seg = segmentAt(segments, j);

if (seg != null) {

//累加所有Segment的操作次数

sum += seg.modCount;

int c = seg.count;

//累加所有segment中的元素个数 size+=c

if (c < 0 || (size += c) < 0)

overflow = true;

}

}

//当这次累加值和上一次累加值一样，证明没有进行新的增删改操作，返回sum

//第一次last为0，如果有元素的话，这个for循环最少循环两次的

if (sum == last)

break;

//记录累加的值

last = sum;

}

} finally {

//如果之前有锁住，解锁

if (retries > RETRIES_BEFORE_LOCK) {

for (int j = 0; j < segments.length; ++j)

segmentAt(segments, j).unlock();

}

}

//溢出，返回int的最大值，否则返回累加的size

return overflow ? Integer.MAX_VALUE : size;

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Java）

2021年Java中高级面试必备知识点总结

在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。

本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。

目录：

（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）

部分内容：

对于每一个做技术的来说，学习是不能停止的，小编把2019年到目前为止Java的核心知识提炼出来了，无论你现在是处于什么阶段，如你所见，这份文档的内容无论是对于你找面试工作还是提升技术广度深度都是完美的。

不想被后浪淘汰的话，赶紧搞起来吧，高清完整版一共是888页，需要的话可以点赞+关注
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
0%以上的Java中高级面试没一点难度。

本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。

目录：

[外链图片转存中…(img-i4yt4Mps-1713819458746)]

（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）

[外链图片转存中…(img-q2u2niko-1713819458746)]

部分内容：

[外链图片转存中…(img-tUKnkWTm-1713819458746)]

[外链图片转存中…(img-2J3Bd6y0-1713819458746)]

[外链图片转存中…(img-tK35Cmd7-1713819458747)]

对于每一个做技术的来说，学习是不能停止的，小编把2019年到目前为止Java的核心知识提炼出来了，无论你现在是处于什么阶段，如你所见，这份文档的内容无论是对于你找面试工作还是提升技术广度深度都是完美的。

不想被后浪淘汰的话，赶紧搞起来吧，高清完整版一共是888页，需要的话可以点赞+关注
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！