JDK源码--ConcurrentSkipListMap（跳跃表）

原理

• Redis有序集合中使用，跟红黑树相同的时间效率，但实现更简单。

读取数据

private V doGet(Object key) {
    if (key == null)
        throw new NullPointerException();
    Comparator<? super K> cmp = comparator;
    // 用循环方式查找，为了防止返回刚好被删除的数据节点，一旦出现这种情况需要重试。
    outer: for (;;) {
    	//根据key查找前驱数据节点 //b是一个小于key的节点，或者head
        for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
            Object v; int c;
            //不存在后继节点则查找失败，跳出外层循环，返回null
            if (n == null)
                break outer;
            Node<K,V> f = n.next;
            //b的后继节点两次读取不一致，重试（存在并发的修改）
            if (n != b.next)                // inconsistent read
                break;
            //后继节点值为null，表示该节点标记为已删除，则移除该节点并重试。
            if ((v = n.value) == null) {    // n is deleted
                n.helpDelete(b, f);
                break;
            }
            //前驱节点被标记为删除，重试
            if (b.value == null || v == n)  // b is deleted
                break;
            //后继节点key值等于入参时，返回后继节点的值（n.value）
            if ((c = cpr(cmp, key, n.key)) == 0) {
                @SuppressWarnings("unchecked") V vv = (V)v;
                return vv;
            }
            //如果后继节点大于key，说明没有key对应的节点，返回
            if (c < 0)
                break outer;
            //后移一个节点，继续查找
            b = n;
            n = f;
        }
    }
    return null;
}

写入数据

//注意返回值，如果旧值更新则返回旧值，如果新值插入则返回null
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;
                //后继节点小于key，则后移一个节点继续查找
                if ((c = cpr(cmp, key, n.key)) > 0) {
                    b = n;
                    n = f;
                    continue;
                }
                //后继节点key等于入参，则执行更新操作（CAS）
                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
            }
			//找到第一个大于key的节点，然后把新增节点插入到该节点之前
            z = new Node<K,V>(key, value, n);
            //如果CAS插入不成功，就一直重试直到成功
            if (!b.casNext(n, z))
                break;         // restart if lost race to append to b
            break outer;
        }
    }

	//以下为更新索引操作（抛硬币方式随机更新索引）
    int rnd = ThreadLocalRandom.nextSecondarySeed();
    //有1/4的概率更新索引
    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) //新增层次的head节点
                    newh = new HeadIndex<K,V>(oldbase, newh, idxs[j], j);
                if (casHead(h, newh)) { //更新head节点
                    h = newh;
                    idx = idxs[level = oldLevel];
                    break;
                }
            }
        }
        // 在
        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);
                    //q原来的right节点value被删除时，q释放到r的链接，同时将q新的right链接到r                   if (n.value == null) {
                        if (!q.unlink(r))
                            break;
                        r = q.right;
                        continue;
                    }
                    //right节点比key小，则向后遍历
                    if (c > 0) {
                        q = r;
                        r = r.right;
                        continue;
                    }
                }
				//此时right节点 >= key
                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;
}

删除数据

final V doRemove(Object key, Object value) {
    if (key == null)
        throw new NullPointerException();
    Comparator<? super K> cmp = comparator;
    outer: for (;;) {
    	//b是一个小于key的节点，或者head
        for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
            Object v; int c;
            if (n == null) //后继节点为null，说明找不到，直接返回
                break outer;
            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;
            //后继节点大于key，说明找不到，返回
            if ((c = cpr(cmp, key, n.key)) < 0)
                break outer;
            //后继节点仍然小于key，继续遍历
            if (c > 0) {
                b = n;
                n = f;
                continue;
            }
            //value值与存储的不一致，禁止删除
            if (value != null && !value.equals(v))
                break outer;
            //CAS将节点值置为null
            if (!n.casValue(v, null))
                break;
            if (!n.appendMarker(f) || !b.casNext(n, f))
                findNode(key);                  // retry via findNode
            else {
                findPredecessor(key, cmp);      // clean index
                if (head.right == null)
                    tryReduceLevel();
            }
            @SuppressWarnings("unchecked") V vv = (V)v;
            return vv;
        }
    }
    return null;
}