ConcurrentSkipListMap
ConcurrentSkipListMap 能解决什么问题？什么时候使用 ConcurrentSkipListMap?
1）ConcurrentSkipListMap 是基于跳表实现的并发排序哈希表，映射可以根据键的自然顺序进行排序，
也可以根据创建映射时所提供的 Comparator 进行排序，具体取决于使用的构造方法。
2）ConcurrentSkipListMap 的 containsKey、get、put、remove 操作及其变体提供预期平均 log(n) 时间开销。
3）ConcurrentSkipListMap 的功能类似于 TreeMap 的线程安全版本。
4）ConcurrentSkipListMap 提供排序功能的同时，由于其插入、删除时需要维护跳表结构，性能低于 ConcurrentHashMap。
如何使用 ConcurrentSkipListMap?
1）需要使用 ConcurrentNavigableMap 的一些特性时使用 ConcurrentSkipListMap。
使用 ConcurrentSkipListMap 有什么风险？
1）ConcurrentSkipListMap 由于底层是通过跳跃表实现的，比较耗内存。
2）新增、删除元素时需要维护跳表结构，存在一定的性能损耗。
ConcurrentSkipListMap 核心操作的实现原理？
创建实例
/**
* 执行键排序的比较器，如果以自然顺序排序则为 null
*/
final Comparator<? super K> comparator;
/** 延迟初始化的顶层索引 */
private transient Index<K,V> head;
/** 延迟初始化的元素计数 */
private transient LongAdder adder;
/** 延迟初始化的键集合 */
private transient KeySet<K,V> keySet;
/** 延迟初始化的值集合 */
private transient Values<K,V> values;
/** 延迟初始化的映射集合 */
private transient EntrySet<K,V> entrySet;
/** 延迟初始化的降序映射 */
private transient SubMap<K,V> descendingMap;
/**
* 头结点和标记节点的 key 为 null，在节点被删除时将 val 置为null
*/
static final class Node<K,V> {
final K key; // currently, never detached
V val;
Node<K,V> next;
Node(K key, V value, Node<K,V> next) {
this.key = key;
this.val = value;
this.next = next;
}
}
/**
* 索引节点以表示跳表的层级
*/
static final class Index<K,V> {
// 驻留节点值
final Node<K,V> node; // currently, never detached
// 下节点
final Index<K,V> down;
// 右节点
Index<K,V> right;
Index(Node<K,V> node, Index<K,V> down, Index<K,V> right) {
this.node = node;
this.down = down;
this.right = right;
}
}
/**
* 创建一个使用自然顺序进行排序的空 ConcurrentSkipListMap 实例
*/
public ConcurrentSkipListMap() {
this.comparator = null;
}
/**
* 创建一个使用比较器 comparator 进行排序的空 ConcurrentSkipListMap 实例
*/
public ConcurrentSkipListMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
添加元素
/**
* 1）如果目标 key 不存在，则写入新的键值对，并返回 null。
* 2）如果目标 key 存在，则替换其关联的值，并返回旧值。
*/
@Override
public V put(K key, V value) {
if (value == null) {
throw new NullPointerException();
}
return doPut(key, value, false);
}
private V doPut(K key, V value, boolean onlyIfAbsent) {
if (key == null) {
throw new NullPointerException();
}
final Comparator<? super K> cmp = comparator;
for (;;) {
/**
* h：head 头结点
* b：predecessor 前置节点
*/
Index<K,V> h; Node<K,V> b;
VarHandle.acquireFence();
// 节点所在的层次
int levels = 0;
// 1）head==null 表示第一次插入元素
if ((h = head) == null) { // try to initialize
// 创建一个标记节点
final Node<K,V> base = new Node<>(null, null, null);
// 创建索引节点
h = new Index<>(base, null, null);
// 更新头节点
b = ConcurrentSkipListMap.HEAD.compareAndSet(this, null, h) ? base : null;
}
// 2）跳表已经有元素存在
else {
/**
* q：index node
* r：right node
* d：down node
*/
for (Index<K,V> q = h, r, d;;) { // count while descending
// 索引节点的右节点不为 null
while ((r = q.right) != null) {
Node<K,V> p; K k;
/**
* 右索引节点的驻留节点为 null ||
* 节点的键为 null ||
* 节点的值为 null
*/
if ((p = r.node) == null || (k = p.key) == null ||
p.val == null) {
// 删除接地啊 q 的右侧节点
ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, r.right);
// 2）查找键大于当前节点键，则继续往右侧查找
} else if (ConcurrentSkipListMap.cpr(cmp, key, k) > 0) {
q = r;
// 3）查找键小于等于当前键，则当层节点已经查找完毕，往下层查找
} else {
break;
}
}
// 1）当前索引节点存在下层节点，则往下层查找
if ((d = q.down) != null) {
// 递增层级
++levels;
// 读取下层节点，重新进入循环并尝试往右侧查找
q = d;
}
else {
/**
* 2）已经到达最后一层
* 则读取驻留其上的节点值，开始玩右侧遍历
*/
b = q.node;
break;
}
}
}
// 前置节点存在
if (b != null) {
Node<K,V> z = null; // new node, if inserted
for (;;) {
/**
* n：node
* k：key
* v：value
* c：Comparisons 比较值
*/
Node<K,V> n, p; K k; V v; int c;
// 1）前置节点的 next 为 null，则表示当前节点是最后一个节点
if ((n = b.next) == null) {
if (b.key == null) {
ConcurrentSkipListMap.cpr(cmp, key, key);
}
c = -1;
}
// 2）节点键为 null
else if ((k = n.key) == null) {
break; // can't append; restart
// 3）节点值为 null，该节点已经被删除，需要从链表中踢除
} else if ((v = n.val) == null) {
ConcurrentSkipListMap.unlinkNode(b, n);
c = 1;
}
// 4）比较查找键和当前键，并且查找键比较大
else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
// 查找下一个节点
b = n;
/**
* 5）如果键相等 && 只有不存在才插入元素，则直接返回；否则尝试更新节点值
*/
} else if (c == 0 &&
(onlyIfAbsent || ConcurrentSkipListMap.VAL.compareAndSet(n, v, value))) {
// 更新成功则返回旧值
return v;
}
/**
* 目标键大于 predecessor.key 小于 predecessor.next.key，
* 将目标键值对插入到他们中间。
*/
if (c < 0 &&
ConcurrentSkipListMap.NEXT.compareAndSet(b, n,
p = new Node<>(key, value, n))) {
// 读取新增节点
z = p;
break;
}
}
if (z != null) {
// 读取随机数
final int lr = ThreadLocalRandom.nextSecondarySeed();
// 有 1/4 的机会基于新增节点生成索引节点
if ((lr & 0x3) == 0) { // add indices with 1/4 prob
final int hr = ThreadLocalRandom.nextSecondarySeed();
long rnd = (long)hr << 32 | lr & 0xffffffffL;
// 新增节点所在的层级，层级从 0 开始
int skips = levels; // levels to descend before add
Index<K,V> x = null;
for (;;) { // create at most 62 indices
// 基于新增节点生成顶层索引节点
x = new Index<>(z, x, null);
if (rnd >= 0L || --skips < 0) {
break;
} else {
rnd <<= 1;
}
}
/**
* 新增索引节点成功 &&
* 如果是新增顶层索引节点 &&
* 增加新的一层
*/
if (ConcurrentSkipListMap.addIndices(h, skips, x, cmp) && skips < 0 &&
head == h) { // try to add new level
// 将新增节点加到顶层
final Index<K,V> hx = new Index<>(z, x, null);
// 创建新的头节点
final Index<K,V> nh = new Index<>(h.node, h, hx);
// 更新头节点
ConcurrentSkipListMap.HEAD.compareAndSet(this, h, nh);
}
if (z.val == null)
{
findPredecessor(key, cmp); // clean
}
}
// 增加计数值
addCount(1L);
return null;
}
}
}
}
/**
* 在插入元素之后新增索引节点，从高层向低层递归插入，之后建立和前置节点的链接
* Recursion depths are exponentially less probable.
*
* @param q 当前层级的起始索引
* @param skips 插入索引时，需要跳过的层级数
* @param x 插入的目标索引
* @param cmp comparator
*/
static <K,V> boolean addIndices(Index<K,V> q, int skips, Index<K,V> x,
Comparator<? super K> cmp) {
Node<K,V> z; K key;
/**
* 1）新增索引节点不为 null &&
* 2）驻留数据节点不为 null &&
* 3）数据节点的键不为 null &&
* 4）起始索引节点不为 null
*/
if (x != null && (z = x.node) != null && (key = z.key) != null &&
q != null) { // hoist checks
boolean retrying = false;
for (;;) { // find splice point
/**
* r：right
* d：down
* c：Comparisons
*/
Index<K,V> r, d; int c;
/**
* 当前节点的右侧节点不为 null
*/
if ((r = q.right) != null) {
Node<K,V> p; K k;
// 1）尝试删除索引节点
if ((p = r.node) == null || (k = p.key) == null ||
p.val == null) {
ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, r.right);
c = 0;
}
// 2）目标键比当前节点键大
else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
// 往右侧查找
q = r;
// 3）目标键和当前键相等
} else if (c == 0) {
break; // stale
}
// 4）目标键比当前节点键小？
} else {
// 已经不存在右侧节点
c = -1;
}
if (c < 0) {
// 下节点不为 null && 层级数 > 0
if ((d = q.down) != null && skips > 0) {
// 递减层级后，往下查找
--skips;
q = d;
}
/**
* 1）下节点不为 null && skip <=0 && 未出现索引添加失败 &&
* 尝试在当前层级添加索引
*/
else if (d != null && !retrying &&
!ConcurrentSkipListMap.addIndices(d, 0, x.down, cmp)) {
// 索引添加失败则退出
break;
} else {
x.right = r;
// 插入新增索引节点
if (ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, x)) {
// 执行成功则退出
return true;
}
else {
retrying = true; // re-find splice point
}
}
}
}
}
return false;
}
读取元素
/**
* 返回指定 key 映射的值，如果 key 不存在，则返回 null
*/
@Override
public V get(Object key) {
return doGet(key);
}
/**
* Gets value for key. Same idea as findNode, except skips over
* deletions and markers, and returns first encountered value to
* avoid possibly inconsistent rereads.
*/
private V doGet(Object key) {
Index<K,V> q;
VarHandle.acquireFence();
if (key == null) {
throw new NullPointerException();
}
final Comparator<? super K> cmp = comparator;
V result = null;
if ((q = head) != null) {
outer: for (Index<K,V> r, d;;) {
/**
* 首先向右侧查找，之后向下查找
*/
while ((r = q.right) != null) {
Node<K,V> p; K k; V v; int c;
// 节点已经被删除
if ((p = r.node) == null || (k = p.key) == null ||
(v = p.val) == null) {
ConcurrentSkipListMap.RIGHT.compareAndSet(q, r, r.right);
// 目标键 > 节点键，则向右侧查找
} else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
q = r;
// 找到目标键
} else if (c == 0) {
// 读取值后返回
result = v;
break outer;
} else {
break;
}
}
// 尝试向下层查找
if ((d = q.down) != null) {
q = d;
} else {
// 已经到达底层
Node<K,V> b, n;
// 读取索引节点驻留的数据节点之后，往右侧遍历查找
if ((b = q.node) != null) {
while ((n = b.next) != null) {
V v; int c;
final K k = n.key;
// 跳过被删除节点和标记节点，如果目标键 > 节点键，也向右侧查找
if ((v = n.val) == null || k == null ||
(c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
b = n;
// 目标键 <= 节点键
} else {
// 如果相等，则直接返回其值
if (c == 0) {
result = v;
}
// 不存在相等的键，则返回 null
break;
}
}
}
break;
}
}
}
return result;
}
/**
* 返回目标 key 关联的值，如果键不存在，则返回 defaultValue
*/
@Override
public V getOrDefault(Object key, V defaultValue) {
V v;
return (v = doGet(key)) == null ? defaultValue : v;
}
替换值
/**
* 如果目标 key 存在，则替换其值为 value，并返回旧值；否则返回 null。
*/
@Override
public V replace(K key, V value) {
// 键和值都非 null
if (key == null || value == null) {
throw new NullPointerException();
}
for (;;) {
Node<K,V> n; V v;
// 没找到目标键
if ((n = findNode(key)) == null) {
// 则返回 null
return null;
}
// 尝试原子设置值，并返回旧值
if ((v = n.val) != null && ConcurrentSkipListMap.VAL.compareAndSet(n, v, value)) {
return v;
}
}
}
/**
* 返回指定 key 映射的节点，如果键不存在，则返回 null。
* 查找过程中会踢除已经被删除键值对的索引节点，并且重新通过 findPredecessor 方法
* 查找基础节点进行再次遍历【如果节点的 key 为 null，则表示它是一个标记节点，
* 它的前置节点将被删除。】
* The traversal loops in doPut, doRemove, and findNear all include the same checks.
*/
private Node<K,V> findNode(Object key) {
if (key == null)
{
throw new NullPointerException(); // don't postpone errors
}
final Comparator<? super K> cmp = comparator;
Node<K,V> b;
// 读取底层有效的前置节点
outer: while ((b = findPredecessor(key, cmp)) != null) {
for (;;) {
Node<K,V> n; K k; V v; int c;
// 1）已经到达尾部，则直接退出
if ((n = b.next) == null) {
break outer; // empty
// 2）当前节点是标记节点
} else if ((k = n.key) == null) {
break; // b is deleted
// 3）当前索引节点驻留的数据节点关联的键值对已经被删除，则踢除当前节点
} else if ((v = n.val) == null) {
ConcurrentSkipListMap.unlinkNode(b, n); // n is deleted
// 4）目标键 > 节点键，则往右侧查找
} else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
b = n;
// 5）找到目标节点，则直接返回
} else if (c == 0) {
return n;
} else {
break outer;
}
}
}
return null;
}
/**
* 删除节点 n
*/
static <K,V> void unlinkNode(Node<K,V> b, Node<K,V> n) {
if (b != null && n != null) {
Node<K,V> f, p;
for (;;) {
if ((f = n.next) != null && f.key == null) {
p = f.next; // already marked
break;
}
// 被删除节点是尾节点
else if (ConcurrentSkipListMap.NEXT.compareAndSet(n, f,
new Node<>(null, null, f))) {
p = f; // add marker
break;
}
}
ConcurrentSkipListMap.NEXT.compareAndSet(b, n, p);
}
}
/**
* 如果目标 key 存在 && 旧值为 oldValue，则替换其值为 value，替换成功返回 true
*/
@Override
public boolean replace(K key, V oldValue, V newValue) {
if (key == null || oldValue == null || newValue == null) {
throw new NullPointerException();
}
for (;;) {
Node<K,V> n; V v;
// 节点不存在
if ((n = findNode(key)) == null) {
return false;
}
if ((v = n.val) != null) {
// 节点值和 oldValue 不相等
if (!oldValue.equals(v)) {
return false;
}
// 原子更新旧值
if (ConcurrentSkipListMap.VAL.compareAndSet(n, v, newValue)) {
return true;
}
}
}
}
删除键值对
/**
* 如果指定的 key 存在，则删除键值对，并返回旧值；否则返回 null
*/
@Override
public V remove(Object key) {
return doRemove(key, null);
}
/**
* 定位节点，将其值置为 null，在其后添加一个删除标记节点，断开前置节点，
* 移除关联的索引节点，并尝试递减层级。
*/
final V doRemove(Object key, Object value) {
if (key == null) {
throw new NullPointerException();
}
final Comparator<? super K> cmp = comparator;
V result = null;
Node<K,V> b;
outer: while ((b = findPredecessor(key, cmp)) != null &&
result == null) {
for (;;) {
Node<K,V> n; K k; V v; int c;
// 1）无后继节点
if ((n = b.next) == null) {
break outer;
// 2）当前节点是一个删除标记节点
} else if ((k = n.key) == null) {
break;
// 3）当前节点的数据节点被删除，则将其踢除
} else if ((v = n.val) == null) {
ConcurrentSkipListMap.unlinkNode(b, n);
// 4）目标键 > 节点键，则往右侧查找
} else if ((c = ConcurrentSkipListMap.cpr(cmp, key, k)) > 0) {
b = n;
// 5）无匹配键，则直接返回
} else if (c < 0) {
break outer;
// 6）如果值匹配，则删除的场景
} else if (value != null && !value.equals(v)) {
break outer;
// 7）将节点值置为 null
} else if (ConcurrentSkipListMap.VAL.compareAndSet(n, v, null)) {
// 读取旧值
result = v;
// 踢除节点
ConcurrentSkipListMap.unlinkNode(b, n);
break; // loop to clean up
}
}
}
if (result != null) {
// 尝试递减层级
tryReduceLevel();
addCount(-1L);
}
return result;
}
/**
* 如果指定的 key 存在 && 键关联的值和 value 相等，则删除键值对，并返回 true。
*/
@Override
public boolean remove(Object key, Object value) {
if (key == null) {
throw new NullPointerException();
}
return value != null && doRemove(key, value) != null;
}