ConcurrentHashMap
jdk8 ConcurrentHashMap结构
1、Node节点一共有5种类型
1、Node节点,是所有节点的父类,可以单独放入桶内,也可以作为链表的头放入桶内。
2、TreeNode节点,继承自Node,是红黑树的节点,此节点不能直接放入桶内,只能是作为红黑树的节点。
3、TreeBin节点,TreeNode的代理节点,可以放入桶内,这个节点下面可以连接红黑树的根节点,所以叫做TreeNode的代理节点。
4、ForwardingNode节点,扩容节点,只是在扩容阶段使用的节点,当前桶扩容完毕后,桶内会放入这个节点,此时查询会跳转到查询扩容后的table,不存储实际数据
5、ReservationNode节点,内部方法使用,暂时可以忽略。
1.1 Node节点
默认桶上的结点就是Node结点。
当出现hash冲突时,Node结点会首先以链表的形式链接到table上,当结点数量超过一定数目时,链表会转化为红黑树。因为链表查找的平均时间复杂度为O(n),而红黑树是一种平衡二叉树,其平均时间复杂度为O(logn)。
Node只有一个next指针,是一个单链表,提供find方法实现链表查询
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next; // 单链表
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
Node<K,V> find(int h, Object k) {
Node<K,V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}
}
1.2 TreeNode节点
TreeNode就是红黑树的结点,TreeNode不会直接链接到table[i]——桶上面,而是由TreeBin链接,TreeBin会指向红黑树的根结点。
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next,
TreeNode<K,V> parent) {
super(hash, key, val, next);
this.parent = parent;
}
// 基于树查找的方法
final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
if (k != null) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk; TreeNode<K,V> q;
TreeNode<K,V> pl = p.left, pr = p.right;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.findTreeNode(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
}
return null;
}
}
1.3 TreeBin节点
TreeBin会直接链接到table[i]——桶上面,该结点提供了一系列红黑树相关的操作,以及加锁、解锁操作。
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root; // 红黑树根节点
volatile TreeNode<K,V> first; // 链表结构头节点
volatile Thread waiter; // 最近一个加写锁的线程
volatile int lockState; // 锁的整体标识
// values for lockState
static final int WRITER = 1; // 写锁状态
static final int WAITER = 2; // 等待获取写锁的状态
static final int READER = 4; // 读锁状态,可以并发,没多一个读锁,lockState累加READER值
另外TreeBin提供了一系列的操作
1、TreeBin(TreeNode<K,V> b),将以b为头结点的链表转换为红黑树.
2、lockRoot(),对红黑树的根结点加写锁
3、unlockRoot(),释放写锁
4、find(int h, Object k),从根结点开始遍历查找,找到“相等”的结点就返回它,没找到就返回null,当存在写锁时,以链表方式进行查找,不阻塞读锁。
final Node<K,V> find(int h, Object k) {
if (k != null) {
for (Node<K,V> e = first; e != null; ) {
int s; K ek;
// 这里有两个特殊情况,以链表的方式进行查找
// 1、有线程证持有锁,这样做能够不阻塞读线程
// 2、有线程等待获取写锁,不在继续加读锁,相当于写优先模式
if (((s = lockState) & (WAITER|WRITER)) != 0) {
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
e = e.next;
}
else if (U.compareAndSwapInt(this, LOCKSTATE, s,
s + READER)) {
TreeNode<K,V> r, p;
try {
p = ((r = root) == null ? null :
r.findTreeNode(h, k, null));
} finally {
Thread w;
if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
(READER|WAITER) && (w = waiter) != null)
LockSupport.unpark(w);
}
return p;
}
}
}
return null;
}
5、removeTreeNode(TreeNode<K, V> p),删除红黑树的结点
a、红黑树规模太小时,返回true,然后进行 树 -> 链表 的转化
b、红黑树规模足够时,不用变换成链表,但删除结点时需要加写锁
6、红黑树的左旋,右旋等一系列算法。
1.4 ForwardingNode节点
1、ForwardingNode是一种临时结点,在扩容进行中才会出现,hash值固定为-1,且不存储实际数据。
2、如果旧table数组的一个hash桶中全部的结点都迁移到了新table中,则在这个桶中放置一个ForwardingNode。
3、读操作碰到ForwardingNode时,将操作转发到扩容后的新table数组上去执行;写操作碰见它时,则尝试帮助扩容,扩容是支持多线程一起扩容的。
4、提供了在新的数组nextTable上进行查找的方法find
Node<K,V> find(int h, Object k) {
// loop to avoid arbitrarily deep recursion on forwarding nodes
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
if (k == null || tab == null || (n = tab.length) == 0 ||
(e = tabAt(tab, (n - 1) & h)) == null)
return null;
for (;;) {
int eh; K ek;
if ((eh = e.hash) == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
if (eh < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
else
return e.find(h, k);
}
if ((e = e.next) == null)
return null;
}
}
}
1.5 ReservationNode节点
1、保留结点.
2、hash值固定为-3, 不保存实际数据
3、只在computeIfAbsent和compute这两个函数式API中充当占位符加锁使用
3、重要属性
transient volatile Node<K,V>[] table; // ConcurrentHashMap内部是一个Node节点的数组table,数组的每一个位置table[i]代表一个桶。根据键的hash值映射到不同的桶内。
private transient volatile int sizeCtl; // 默认为0,-1代表正在扩容,-N表示有N-1个线程正在进行扩容操作,正数表示hash表还没有被扩容,数值表示下一次扩容的大小,大小为数组的0.75倍,和hashmap中的loadfactor是对应的
private transient volatile int transferIndex; // 表示扩容操作,剩余待复制数组的下标
4、三个核心原子操作方法
// 获得在i位置上的Node节点
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
// 利用CAS算法设置i位置上的Node节点。之所以能实现并发是因为他指定了原来这个节点的值是多少
// 在CAS算法中,会比较内存中的值与你指定的这个值是否相等,如果相等才接受你的修改,否则拒绝你的修改
// 因此当前线程中的值并不是最新的值,这种修改可能会覆盖掉其他线程的修改结果 有点类似于SVN
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
// 利用volatile方法设置节点位置的值
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V>