转载：https://blog.csdn.net/fw0124/article/details/42780679

为什么选择跳表

说起跳表，我们还是要从二分查找开始。
二分查找的关键要求有两个，
1 数据能够按照某种条件进行排序。
2 可以通过某种方式，取出该数据集中任意子集的中间值。
能够满足的数据结构主要是有序数组，但对于数据量不断变化的场景来说，有序数组很难能够高效的进行写入。
链表是一种最容易处理数据不断增加结构的有序数据结构，并且因为已经有了无锁完成多线程链表写入的算法，因此链表对于并发的支持度是非常好的然而链表却不能够进行二分查找，因为无法取到任意子集的中值。
所以人们又去想办法基于树来做能够既支持写入，又能够通过“预先找到中值并写到父节点”的方式来提前将中值准备好，这就是平衡有序二叉树。不过，无论是AVL还是红黑树，这个预先找到中值并写入到父节点的操作的都是非常复杂的，对于复杂的操作来说，想使用常见的无锁操作就几乎不可能了。

最后，综合一下，链表结构能够做到并发无锁的增加新节点，但不能很容易的访问到中值（因为链表只能从头部遍历或尾部遍历）。平衡有序二叉树则相反，虽然很容易可以访问到全部数据的中值，但无法做到并发无锁的增加新节点。
在90年代之前，人们一直以“这就是生活” 来安慰自己，认为鱼与熊掌不可兼得。但在90年代，William Pugh 在他的论文中提出了一种新的数据结构，很巧妙的解决了这个矛盾，另外也八卦一下，其实目前Java领域很流行的find bugs静态代码分析工具也是william发明的~

跳表是一种随机化的数据结构，目前开源软件 Redis 和 LevelDB 都有用到它，它的效率和红黑树以及 AVL 树不相上下，但跳表的原理相当简单，只要你能熟练操作链表，就能轻松实现一个 SkipList。

有序表的搜索

考虑一个有序表：

从该有序表中搜索元素 < 23, 43, 59 > ，需要比较的次数分别为 < 2, 4, 6 >，总共比较的次数

为 2 + 4 + 6 = 12 次。有没有优化的算法吗?  链表是有序的，但不能使用二分查找。类似二叉

搜索树，我们把一些节点提取出来，作为索引。得到如下结构：

这里我们把 < 14, 34, 50, 72 > 提取出来作为一级索引，这样搜索的时候就可以减少比较次数了。

我们还可以再从一级索引提取一些元素出来，作为二级索引，变成如下结构：

这里元素不多，体现不出优势，如果元素足够多，这种索引结构就能体现出优势来了。

跳表

下面的结构是就是跳表：

跳表具有如下性质：

(1) 由很多层结构组成

(2) 每一层都是一个有序的链表

(3) 最底层(Level 1)的链表包含所有元素

(4) 如果一个元素出现在 Level i 的链表中，则它在 Level i 之下的链表也都会出现。

(5) 每个节点包含两个指针，一个指向同一链表中的下一个元素，一个指向下面一层的元素。

跳表的搜索

例子：查找元素 117

(1) 比较 21， 比 21 大，往后面找

(2) 比较 37,   比 37大，比链表最大值小，从 37 的下面一层开始找

(3) 比较 71,  比 71 大，比链表最大值小，从 71 的下面一层开始找

(4) 比较 85， 比 85 大，从后面找

(5) 比较 117， 等于 117， 找到了节点。

可以看到，利用这种结构如果我们能够比较准确的在链表里将数据排好序，并且level1中每两个元素中拿出一个元素推送到更高的层级level2中，然后在level2中也按照每两个元素拿出一个元素推送到更高层级的level3中…依此类推，就可以构建出一个查询时间复杂度为O(log2n)的查找数据结构了。

但这里有个关键的难在于：如何能够知道，当前写入的元素是否应该被推送到更高的层级呢？这也就对应了原来avl,红黑里面为什么要做如此复杂的旋转的原因。而在william的解决方案里，他选择了一条完全不相同的路来做到这一点。

这也是skiplist里面一个最大的创新点，就是引入了一个新条件：概率。与传统的根据临近元素的来决定是否上推的avl或红黑树相比。Skiplist则使用概率这个完全不需要依托集合内其他元素的因素来决定这个元素是否要上推。这种方式的最大好处，就是可以让每一次的插入都变得更“独立”，而不需要依托于其他元素插入的结果。 这样就能够让冲突只发生在数据真正写入的那一步操作上，而我们已经在前面的文章里面知道了，对于链表来说，数据的写入是能够做到无锁的写入新数据的，于是，利用skiplist,就能成功的做到无锁的有序平衡“树”（多层级）结构。

我们可以把skiplist的写入分为两个步骤，第一个步骤是找到元素在整个顺序列表中要写入的位置，这个步骤与我们上面讲到的读取过程是一致的。
然后下一个步骤是决定这个数据是否需要从当前层级上推到上一个层级，具体的做法是从最低层级level1开始,写入用户需要写入的值，并计算一个随机数，如果是0，则不上推到高一层，而如果是1，则上推到高一个层，然后指针跳跃到高一个层级，重复进行随机数计算来决定是否需要推到更高的层级，如果最高层中只有自己这个元素的时候，则也停止计算随机数（因为不需要再推到更高层了）。

最后，还有个问题就是如何解决并发写入的问题，为了阐述清楚如何能够做到并发写，我们需要先对什么叫”一致性的写”，进行一下说明。
一般的人理解数据的一致性写的定义可能是：如果写成功了你就让我看到，而如果没写成功，你就不让我看到呗。
但实际上这个定义在计算机里面是无法操作的，因为我们之前也提到过，计算机其实就是个打字机，一次只能进行一个操作，针对复杂的操作，只能通过加锁来实现一致性。但加锁本身的代价又很大，这就形成了个悖论，如何能够既保证性能，又能够实现一致性呢？
这时候就需要我们对一致性的定义针对多线程环境进行一下完善：在之前的定义，我们是把写入的过程分为两个时间点的，一个时间点是调用写入接口前，另一个时间点是调用写入接口后。但其实在多线程环境下，应该分为三个时间点，第一个是调用写入接口前，第二个是调用写入接口，但还未返回结果的那段时间，第三个是调用写入接口，返回结果后。
然后我们来看看，针对这三个时间点应该如何选择，才能保证数据的一致性：
对于第一个时间点，因为还没有调用写入接口，所以所有线程（包含调用写入的线程）都不应该能够从这个映射中读取到待写入的数据。
第二个时间点，也就是写入操作过程中，我们需要能够保证：如果数据已经被其他线程看到过了，那么再这个时间点之后的所有时间点，数据应该都能够被其他线程看到，也就是说不能出现先被看到但又被删掉的情况。
第三个时间点，这个写入的操作应该能够被所有人看到。

已经定义好了一致性的规范，下面就来看看这个无锁并发的skiplist是如何处理好并发一致性的。
首先我们需要先了解一下链表是如何能够做到无锁写入的：
对于链表类的数据结构来说，如果想做到无锁，主要就是解决以下的问题，如何能够让当前线程知道，目前要插入新元素的位置，是否有其他人正在插入？ 如果有的话，那么就自旋等待，如果没有，那么就插入。利用这个原理，把原来的多步指针变更操作利用compare and set的方式转换为一个伪原子操作。这样就可以有效的减少锁导致的上下文切换开销，在争用不频繁的情况下，极大的提升性能。（这只是思路，关于linkedlist的无锁编程细节，可以参照A pragmatic implementation of non-blocking linked lists，这篇文章）
利用上面链表的无锁写入，我们就能够保证，数据在每一个level内的写是保证无锁写入的。并且，因为每一次有新的数据写入的时候其他尝试写入的线程也都能感知的到，所以这些并行写入的数据可以通过不断相互比较的方式来了解到，自己这个要写入的数据与其他并行写入的数据之间的大小关系，从而可以动态的进行调整以保证在每一层内，数据都是绝对有序的。
同一个level的一致性解决了，那么不同level之间的一致性是如何得到解决的呢？这就与我们刚才定义的一致性规范紧密相关了。因为数据的写入是从低层级开始，一层一层的往更高的层级推送的。而数据读取的时候，则是从最高层级往下读取的。又因为数据是绝对有序的，那么我们就一定可以认为，只要最低层级（level0）内存在了的数据，那么他就一定能够被所有线程看到。而如果在上推的过程中出现了任何异常，其实都是没关系的，因为上推的唯一目的在于加快检索速度，所以就算因为异常没有上推，也只是降低了查询的效率，对数据的可见性完全没有影响。
这个设计确实是非常的巧妙~

这样，虽然每个元素的具体能够到达哪个层级是随机的，但从宏观上来看，低层元素的个数基本上是高层元素个数的一倍。从宏观上来看，如果按照我们上面定义的自最高层级依次往下遍历的读取模式，那么整个查询的时间复杂度就是O(log2n)。

下面来介绍一些优化的思路，因为进行随机数的运算本身也是个很消耗cpu的操作，所以，一种最常见的优化就是，如果在插入的时候就能直接算出这个数据应该往高层推的总次数，那么就不需要算那么多次随机数了，每次写入只需要算一次就行了。
第二个优化的思路是如何能够实现一个高性能的随机数算法。

Skiplist是一个很好的数据结构，因为它足够简单，性能又好，除了运气非常差的时候效率很低，其他时候都能做到很好的查询效率，赌博什么的最喜欢了~~~最重要的是，它还足够简单和容易理解！

跳表的插入

先确定该元素要占据的层数 K（采用丢硬币的方式，这完全是随机的）

然后在 Level 1 ... Level K 各个层的链表都插入元素。

例子：插入 119， K = 2

如果 K 大于链表的层数，则要添加新的层。

例子：插入 119， K = 4

丢硬币决定 K

插入元素的时候，元素所占有的层数完全是随机的，相当于做多次丢硬币的实验，如果遇到正面，继续丢，遇到反面，则停止，

用实验中丢硬币的次数 K 作为元素占有的层数。显然随机变量 K 满足参数为 p = 1/2 的几何分布，

K 的期望值 E[K] = 1/p = 2. 就是说，各个元素的层数，期望值是 2 层。

跳表的高度。

n 个元素的跳表，每个元素插入的时候都要做一次实验，用来决定元素占据的层数 K，

跳表的高度等于这 n 次实验中产生的最大 K

跳表的空间复杂度分析

根据上面的分析，每个元素的期望高度为 2， 一个大小为 n 的跳表，其节点数目的

期望值是 2n。

跳表的删除

在各个层中找到包含 x 的节点，使用标准的 delete from list 方法删除该节点。

例子：删除 71

下面我们使用一些通用的标准对skiplis进行一下简单的评价：

1. 是否支持范围查找
因为是有序结构，所以能够很好的支持范围查找。

2. 集合是否能够随着数据的增长而自动扩展
可以，因为核心数据结构是链表，所以是可以很好的支持数据的不断增长的

3. 读写性能如何
因为从宏观上可以做到一次排除一半的数据，并且在写入时也没有进行其他额外的数据查找性工作，所以对于skiplist来说，其读写的时间复杂度都是O(log2n)

4. 是否面向磁盘结构
磁盘要求顺序写，顺序读，一次读写必须是一整块的数据。而对于skiplist来说，查询中每一次从高层跳跃到底层的操作，都会对应一次磁盘随机读，而skiplist的层数从宏观上来看一定是O(log2n)层。因此也就对应了O(log2n)次磁盘随机读。
因此这个数据结构不适合于磁盘结构。

5. 并行指标
终于来到这个指标了， skiplist的并行指标是非常好的，只要不是在同一个目标插入点插入数据，所有插入都可以并行进行，而就算在同一个插入点，插入本身也可以使用无锁自旋来提升写入效率。因此skiplist是个并行度非常高的数据结构。

6. 内存占用
与平衡二叉树的内存消耗基本一致。