多线程篇（其它容器- ConcurrentSkipListMap）（持续更新迭代）

W哥教你学后端

于 2024-09-12 21:02:44 发布

阅读量781

点赞数 13

分类专栏： JUC 文章标签： java

本文链接：https://blog.csdn.net/qq_51226710/article/details/142185923

版权

JUC 专栏收录该内容

43 篇文章 0 订阅

订阅专栏

一、前言

一个可伸缩的并发实现，这个map实现了排序功能，默认使用的是对象自身的compareTo方法，如果提供了比较

器，使用比较器的比较方法。简单来说ConcurrentSkipListMap是TreeMap的并发实现，但是为什么没有称之为

ConcurrentTreeMap呢？这和其自身的实现有关。该类是SkipLists的变种实现，提供了log(n)的时间开销：

containsKey、get、put、remove。Insertion, removal, update, and access等操作都是线程安全的。迭代器

是弱一致性的，升序迭代器比降序的快。该map的size方法不是常量时间开销，需要遍历，所以这

个值在并发的时候可能不准。该map也不允许空键或值。

二、实现原理

此类实现了一个二维树状跳跃链表，index level由持有数据的基本节点的独立节点表示。

有两个原因采取这种方法，而不是使用数组：

数组实现复杂性更高，开销更大，
我们可以使用开销更小的算法来完成大量遍历的索引列表而不是用于基本链表。

下图是一个基础的两级索引的list结构：

基础的算法使用的是the HM linked ordered set algorithm的变种。这些算法的基本原理是在删除节点时

标记删除节点的下一个节点指针，以避免并发插入冲突，当遍历跟踪三元组（前置节点，当前结点，后继节点）

时，决定何时以及如何将这些已删除的结点断开。

节点直接使用CAS标记next指针，而不是使用标记位来标记列表删除。在删除时，不是标记一个指针，而是在另

一个被认为是标记指针的结点中进行拼接。此外使用删除标记，链表中也有空的元素被看成是删除，这类似于懒

删除模式。如果一个节点的值为null，就被认为是逻辑删除了，并忽略。下面是删除一个节点的示意图，删除n节

点，初始状态如下：

CAS设置n的值从非null变成null。从这个时刻开始，没有public操作会认为这个节点存在，然而其它正在进

行的insert和delete可能依旧在改变其next指针。

CAS设置n的next指针为一个新的标记节点，当这个节点存在时，没有其它的结点能添加在n后面，这是为了

防止删除错误。

CAS设置b的next指针，越过n和marker节点，这个时刻开始，没有遍历方法能够访问到n，其可以被垃圾回

收了。第一步失败会导致简单的重试，2,3步失败了也不要紧，因为其他操作会忽视null节点，并且会帮助逻

辑删除节点从链表移除。

三、数据结构

上图是一个数据结构，链表的头结点，比较器，和一个头结点的对象。

Node节点也比较标准，键值和下一个节点，内部方法如下：

casValue：CAS设置结点的value
casNext：CAS设置结点的next
isMarker：判断该节点是否是Marker节点，依据就是Marker节点的value就是其本身
isBaseHeader：判断该节点是否是头结点，依据就是head节点的value是类的BASE_HEADER的对象
appendMarker：CAS设置结点的next节点为marker节点，参数是该节点原来的next结点
helpDelete：帮助删除节点(当该节点是value为null的时候)
getValidValue：返回当前结点的值
createSnapshot：创建该节点的键值对快照，是一个不可改变的集合

Index就是该类的数据结构了，其对Node继续了封装，多了down和right节点，这是一个跳跃表的基本结构。

里面的方法如下：

casRight：CAS设置该节点的right指针
indexesDeletedNode：判断该节点是否被逻辑删除了
link：CAS设置新的后继节点，参数是原后继节点和新的后继节点
unlink：CAS设置该节点的后继节点的后继节点为该节点的后继节点，就是将该节点的后继节点移除

HeadIndex继承自Index，补充了Index缺少了level字段。

四、基本操作

1. 获取一个键值对

步骤如下：

通过key找到跳跃表key的前一个节点b，该key的键值就是在这个节点b的后面。
如果b的next节点n为null，意味着b为最后节点，没有元素可找，跳出循环
再次检测b的next节点是否是n，不是意味着被put抢先插入了，重新找前置节点进行循环
n节点值为null，已逻辑删除，helpDelete帮助移除该节点，跳出循环，重新找前置节点
b节点value为null，或n==n.value（marked节点）b被移除，跳出循环，重新找前置节点
比较n的key和获取的key，相等就返回值，<0就跳出循环。没找到就继续判断n.next.

查找指定key开始遍历的跳跃表前置节点方法如上图，步骤如下：

从头结点开始遍历，当前结点的右节点为r
r不为null，但是值为null，尝试移除，移除失败重新从head开始遍历，成功继续找下一个跳跃点，继续遍

历。如果r值不为null，但是比较出来key的值要大，意味着还可以跳跃这段，继续找下一个跳跃点。

找到合适的跳跃点，就去找该跳跃点的起始节点，down存在就是要当前跳跃点的结点，存在就在down中查

找合适的跳跃点。

如果对这个结构有疑惑的，可以参考：这里。来理解一下什么是跳跃表。

2. 放入一个元素

private V doPut(K key, V value, boolean onlyIfAbsent) {
    Node<K,V> z;             // added node
    if (key == null)
        throw new NullPointerException();
    Comparator<? super K> cmp = comparator;
    outer: for (;;) {
        for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
            if (n != null) {
                Object v; int c;
                Node<K,V> f = n.next;
                if (n != b.next)               // inconsistent read
                    break;
                if ((v = n.value) == null) {   // n is deleted
                    n.helpDelete(b, f);
                    break;
                }
                if (b.value == null || v == n) // b is deleted
                    break;
                if ((c = cpr(cmp, key, n.key)) > 0) {
                    b = n;
                    n = f;
                    continue;
                }
                if (c == 0) {
                    if (onlyIfAbsent || n.casValue(v, value)) {
                        @SuppressWarnings("unchecked") V vv = (V)v;
                        return vv;
                    }
                    break; // restart if lost race to replace value
                }
                // else c < 0; fall through
            }
 
            z = new Node<K,V>(key, value, n);
            if (!b.casNext(n, z))
                break;         // restart if lost race to append to b
            break outer;
        }
    }
 
    int rnd = ThreadLocalRandom.nextSecondarySeed();
    if ((rnd & 0x80000001) == 0) { // test highest and lowest bits
        int level = 1, max;
        while (((rnd >>>= 1) & 1) != 0)
            ++level;
        Index<K,V> idx = null;
        HeadIndex<K,V> h = head;
        if (level <= (max = h.level)) {
            for (int i = 1; i <= level; ++i)
                idx = new Index<K,V>(z, idx, null);
        }
        else { // try to grow by one level
            level = max + 1; // hold in array and later pick the one to use
            @SuppressWarnings("unchecked")Index<K,V>[] idxs =
                (Index<K,V>[])new Index<?,?>[level+1];
            for (int i = 1; i <= level; ++i)
                idxs[i] = idx = new Index<K,V>(z, idx, null);
            for (;;) {
                h = head;
                int oldLevel = h.level;
                if (level <= oldLevel) // lost race to add level
                    break;
                HeadIndex<K,V> newh = h;
                Node<K,V> oldbase = h.node;
                for (int j = oldLevel+1; j <= level; ++j)
                    newh = new HeadIndex<K,V>(oldbase, newh, idxs[j], j);
                if (casHead(h, newh)) {
                    h = newh;
                    idx = idxs[level = oldLevel];
                    break;
                }
            }
        }
        // find insertion points and splice in
        splice: for (int insertionLevel = level;;) {
            int j = h.level;
            for (Index<K,V> q = h, r = q.right, t = idx;;) {
                if (q == null || t == null)
                    break splice;
                if (r != null) {
                    Node<K,V> n = r.node;
                    // compare before deletion check avoids needing recheck
                    int c = cpr(cmp, key, n.key);
                    if (n.value == null) {
                        if (!q.unlink(r))
                            break;
                        r = q.right;
                        continue;
                    }
                    if (c > 0) {
                        q = r;
                        r = r.right;
                        continue;
                    }
                }
 
                if (j == insertionLevel) {
                    if (!q.link(r, t))
                        break; // restart
                    if (t.node.value == null) {
                        findNode(key);
                        break splice;
                    }
                    if (--insertionLevel == 0)
                        break splice;
                }
 
                if (--j >= insertionLevel && j < level)
                    t = t.down;
                q = q.down;
                r = q.right;
            }
        }
    }
    return null;
}

put方法主要经历了2个步骤：

1：查找合适的位置，插入该节点。