ConcurrentSkipListMap

在JDK的并发包中，除了常用的哈希表外，还有一种数据结构–跳表。

跳表是一种可以用来快速查找的数据结构，有点类似与平衡树。它们都可以对元素进行快速查找。就查询性能而言，跳表的时间复杂度是O（log n）

跳表的结构图如下：

最底层呢的链表维护了跳表内的所有的元素，每上面一层链表都是下面一层的子集，一个元素插入哪些层是完全随机的。
跳表里面的数据是有序的。
在查找时，可以从顶级链表开始找，一旦发现被查找的元素大于当前链表中的取值，就会转入下一层链表继续找。这就是说在查找的过程中，搜索是跳跃式的。

我们看跳表的内部实现：

首先是Node ，一个Node表示节点，里面含有两个重要的元素key 和value。每个node还会指向下一个Node，因此还有一个next。

  static final class Node<K,V> {        final K key;        volatile Object value;        volatile Node<K,V> next;

另外一个重要的数据结构是Index， 这个表示索引，它内部包装了Node，同时增加了向下的引用和向右的引用

    static class Index<K,V> {        final Node<K,V> node;        final Index<K,V> down;        volatile Index<K,V> right;

此外，对于每一层的表头，还需要记录当前处于哪一层，为此，还需要一个称为HeadIndex

static final class HeadIndex<K,V> extends Index<K,V> {        final int level;        HeadIndex(Node<K,V> node, Index<K,V> down, Index<K,V> right, int level) {            super(node, down, right);            this.level = level;        }    }

普通方法源码分析：

我们看下put方法：

public V put(K key, V value) {   if (value == null)       throw new NullPointerException();   // @By Vicky:实际调用内部的doPut方法   return doPut(key, value, false);}  /**     * Main insertion method.  Adds element if not present, or     * replaces value if present and onlyIfAbsent is false.     * @param kkey the key     * @param value  the value that must be associated with key     * @param onlyIfAbsent if should not insert if already present     * @return the old value, or null if newly inserted     */    private V doPut(K kkey, V value, boolean onlyIfAbsent) {        Comparable<? super K> key = comparable(kkey);  // 将key封装为 Comparable 便于进行比较        for (;;) {            Node<K,V> b = findPredecessor(key);     //  查找前一个节点            Node<K,V> n = b.next;// 前一个节点的 后一个节点  //  即 新节点 插入在b和n之间。            for (;;) {                if (n != null) {//n==null 表示 b为最后一个节点                    Node<K,V> f = n.next;// 为了后面的判断，以防n删除。                    if (n != b.next)  //如果不等表示 中间已经有元素插入了             // inconsistent read                        break;                    Object v = n.value;                    if (v == null) {               // n is deleted                        n.helpDelete(b, f);                        break;                    }                    if (v == n || b.value == null) // b is deleted                        break;                    int c = key.compareTo(n.key);                    if (c > 0) { //大于0进行，则判断下一个节点，知道n==null 或者 c＜０                        b = n;                        n = f;                        continue;                    }                    if (c == 0) {                        if (onlyIfAbsent || n.casValue(v, value))                            return (V)v;                        else                            break; // restart if lost race to replace value                    }                    // else c < 0; fall through                }　　　　// 创建一个节点，next指向n                Node<K,V> z = new Node<K,V>(kkey, value, n);                if (!b.casNext(n, z))                    break;         // restart if lost race to append to b           // 随机计算一个层级     　　　　　　int level = randomLevel();                if (level > 0)                    insertIndex(z, level);                return null;            }        }    }

接下来我们看下里面的findPredecessor(key)　方法

/**     * Returns a base-level node with key strictly less than given key,     * or the base-level header if there is no such node.  Also     * unlinks indexes to deleted nodes found along the way.  Callers     * rely on this side-effect of clearing indices to deleted nodes.     * @param key the key     * @return a predecessor of key     */    private Node<K,V> findPredecessor(Comparable<? super K> key) {        if (key == null)            throw new NullPointerException(); // don't postpone errors        for (;;) {            Index<K,V> q = head;　　//从最高层的节点开始遍历            Index<K,V> r = q.right;//右边的一节点            for (;;) {                if (r != null) {                    Node<K,V> n = r.node;                    K k = n.key;                    if (n.value == null) {//表示此节点已删除                        if (!q.unlink(r))　//删除此节点                            break;           // restart                        r = q.right;         // reread r                        continue;                    }                    if (key.compareTo(k) > 0) {// key大　继续循环取下一个节点。                        q = r;                        r = r.right;                        continue;                    }                }　　　　　　　　// 此时key 小于　K ,大于　ｑ的node 的key .                 Index<K,V> d = q.down;　//查找下一层                if (d != null) {                    q = d;                    r = d.right;                } else　　// 表示到了最后一层                    return q.node;            }        }    }