ConcurrentHashMap jdk1.8废弃了分段锁segment的机制
采用数组+链表+红黑树的数据结构，利用CAS+synchronized 来保证并发更新的安全
table：数组，用来存储Node节点数据
Node:保存key,value键值对，还有下一个节点的引用next,其中key是final类型，如果key是可变的，那么Key的哈希值就可能改变。可变对象作为Key会造成数据丢失。所以这里保证key不可变。
value，next是volatile类型，保证每次更新都会对其他线程可见。
nextTable：扩容时新生成的数组，默认大小是table的两倍
ForwardingNode: 一个特殊的Node节点，hash值为-1，存储nextTable的引用。只有table发生扩容的时候才有用，作为一个占位符放在table中表示当前节点为null或者已经被移动。
table在第一次put操作的时候被初始化
sizeCtl含义； table未初始化，表示需要初始化的大小，table已经初始化，表示table的容量。容量为table数组大小的0.75倍，通过 n - (n >>> 2) 这个公式算得。-1代表table正在初始化
-N表示有N-1个线程正在进行扩容操作。
初始化table的时候首先会判断sizeCtl的值是否小于0，如果是的话说明，table已经被一个线程抢先初始化了。那么当前线程只要调用Thread.yield()让出CPU执行时间片就可以了
如果大于0，先利用CAS将sizeCtl的值置为-1 然后去初始化table，最后将sizeCtl的值置为table的容量大小。
put操作。
采用CAS+synchronized 来保证并发更新的安全来保证线程安全
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 将key的hashcode rehash一次，降低碰撞概率。
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
// 第一次进来，table还没初始化，就初始化table
tab = initTable();
// 走到这里说明table已经初始化了 通过hash值计算table的索引下标 用tabAt方法取到当前下标的元素。
// tabAt方法是通过Unsafe.getObjectVolatile方法直接取到最新内存值。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//判断如果当前数组下标元素为null 则用CAS操作创建一个Node节点
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 如果hash值是-1 说明数组正在扩容当中，则帮助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
// 走到这里 说明当前数组下标已经有了节点，则插入链表 synchronized在节点f上进行同步
V oldVal = null;
synchronized (f) {
// 再次做一下判断，防止被其他线程修改
if (tabAt(tab, i) == f) {
if (fh >= 0) {
// binCount 代表节点数
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
// 如果key相同，则覆盖旧值
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
// key 不同，将新的node节点插入链表尾部
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
// 红黑树
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 如果节点数大于默认值8 则将链表转换为红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
get操作：
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 首先计算key的hash值
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
// 通过tabAt方法直接拿到数组下标的链表头节点，如果当前key值与头结点key的内存地址相等则直接返回当前节点的value
// 如果不相等再比较equals方法，equals相等也返回当前节点的value
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0)
// 小于0 说明当前节点是ForwardingNode 表示数组正在扩容，因为ForwardingNode 存储了新数组的引用 则调用find方法去新数组去找
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {
// 遍历链表找到相应的值
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
// 如果table为空 直接返回null
return null;
}
看到jdk源码为什么经常在方法中创建一个临时变量替代成员变量、类变量
存取堆栈变量如此快是因为JVM 存取堆栈变量比它存取 成员变量 或 静态变量执行的操作少。
JVM 是一种基于堆栈的虚拟机，因此优化了对堆栈数据的存取和处理。所有局部变量都存储在一个局部变量表中，在 Java 操作数堆栈中进行处理，并可被高效地存取。
存取 成员变量 和 静态变量 成本更高，因为 JVM 必须使用代价更高的操作码，并从常数存储池中存取它们。（常数存储池保存一个类型所使用的所有类型、字段和方法的符号引用。）
通常，在第一次从常数存储池中访问 static 变量或实例变量以后，JVM 将动态更改字节码以使用效率更高的操作码。尽管有这种优化，堆栈变量的存取仍然更快。
参考 https://blog.csdn.net/hl_java/article/details/79288909
网友评论