skiplist 跳表（2）-----细心学习

快速了解skiplist请看：skiplist 跳表（1）


http://blog.sina.com.cn/s/blog_693f08470101n2lv.html

本周我要介绍的数据结构，是我非常非常喜欢的一个数据结构，因为咱也是吃过平衡二叉树的苦的人啊T_T ，神马左旋，右旋，上旋，下旋，看原理的时候就已经晕晕乎乎的了，再看源码，发现比原理还复杂，心理就想，这东西是不是就是为了让我挂科给学校交重修费来拯救学校财政的东西啊？！。。

 

当然，现在再来看，这些东西有其非常重要的作用，只是确实有点复杂了，不过，突然有一天，有个结构进入了我的视野，第一次听说是在redis上面看到，后来发现原来java的并发包里也早就实现了这个结构，可以做到很高的并发度，几乎是全部无锁的结构，而最重要的是，这个结构的原理非常的简单！ 这么漂亮的结构才是拯救地球的大舅星啊~~~

 

没错，今天我们来介绍skiplist跳表。

 

说起跳表，我们还是要从二分查找开始。二分查找的关键要求有两个，1，数据能够按照某种条件进行排序。2，可以通过某种方式，取出该数据集中任意子集的中间值。

能够满足的数据结构主要是有序数组，但对于数据量不断变化的场景来说，有序数组很难能够高效的进行写入。链表是一种最容易处理数据不断增加结构的有序数据结构，并且因为已经有了无锁完成多线程链表写入的算法，因此链表对于并发的支持度是非常好的（我们后面会介绍这个算法），然而链表却不能够进行二分查找，因为无法取到任意子集的中值。

所以人们又去想办法基于树来做能够既支持写入，又能够通过“预先找到中值并写到父节点”的方式来提前将中值准备好，这就是平衡有序二叉树。不过，无论是AVL还是红黑树，这个预先找到中值并写入到父节点的操作的都是非常复杂的，对于复杂的操作来说，想使用常见的无锁操作就几乎不可能了。

最后，综合一下，链表结构能够做到并发无锁的增加新节点，但不能很容易的访问到中值（因为链表只能从头部遍历或尾部遍历）。平衡有序二叉树则相反，虽然很容易可以访问到全部数据的中值，但无法做到并发无锁的增加新节点。

在90年代之前，人们一直以“这就是生活” 来安慰自己，认为鱼与熊掌不可兼得。但在90年代，William Pugh在他的论文中提出了一种新的数据结构，很巧妙的解决了这个矛盾，另外也八卦一下，其实目前Java领域很流行的find bugs静态代码分析工具也是william发明的~

首先我们先定义一个概念，叫层(level) ,为了方便理解，大家可以直接对应到平衡有序二叉树里面的树的高度。

 

每一层在逻辑上都是一个链表，既然是链表，那么自然也就只能从头部遍历或从尾部遍历咯。

一个标准的skiplist在内存中可能是这样的：

Level2:0,4

Level1:0,2,4,6,9

Level0:0,1,2,3,4,5,6,7,8,9

 

可以看到，层级越高，数据量越小，并且，高层级的元素都有一个到低层级元素的指针，这样他可以很容易的通过指针跳转到更底层的元素上面。

 

下面让我们来看看读取的逻辑，比如如果要读取6，那么从最高层级的链表的头部（从左向右）依次读取数据，发现6>4，于是在通过Level2 的4 这个元素到level1的4这个元素的指针，跳跃到Level1，然后从Level1的4这个元素继续往右面找发现下一个元素就是6，于是将整个6所对应的元素返回。

那么要找3的话应该怎么操作呢？

仍然是从最高层级level2的头部开始遍历，发现0<3<4 . 于是利用level2的0这个元素到level1的0这个元素的指针，跳跃到level1的0元素，继续向右遍历，发现2<3<4。于是利用Level1的2这个元素到level0的2这个元素的指针，跳跃到level0的2这个元素上，继续向右遍历找到元素3，于是将整个3所对应的元素返回。

 

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

 

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

 

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

 

下面我们就来看看如何利用概率来决定某个元素是否需要上推的。

让我们先用一个简单的模式来说明解决问题的思路，然后再探讨如何进行优化。

我们可以把skiplist的写入分为两个步骤，第一个步骤是找到元素在整个顺序列表中要写入的位置，这个步骤与我们上面讲到的读取过程是一致的。

然后下一个步骤是决定这个数据是否需要从当前层级上推到上一个层级，具体的做法是从最低层级level0开始,写入用户需要写入的值，并计算一个随机数，如果是0，则不上推到高一层，而如果是1，则上推到高一个层，然后指针跳跃到高一个层级，重复进行随机数计算来决定是否需要推到更高的层级，如果最高层中只有自己这个元素的时候，则也停止计算随机数（因为不需要再推到更高层了）。

最后，还有个问题就是如何解决并发写入的问题，为了阐述清楚如何能够做到并发写，我们需要先对什么叫”一致性的写”，进行一下说明。

一般的人理解数据的一致性写的定义可能是：如果写成功了你就让我看到，而如果没写成功，你就不让我看到呗。

但实际上这个定义在计算机里面是无法操作的，因为我们之前也提到过，计算机其实就是个打字机，一次只能进行一个操作，针对复杂的操作，只能通过加锁来实现一致性。但加锁本身的代价又很大，这就形成了个悖论，如何能够既保证性能，又能够实现一致性呢？

这时候就需要我们对一致性的定义针对多线程环境进行一下完善：在之前的定义，我们是把写入的过程分为两个时间点的，一个时间点是调用写入接口前，另一个时间点是调用写入接口后。但其实在多线程环境下，应该分为三个时间点，第一个是调用写入接口前，第二个是调用写入接口，但还未返回结果的那段时间，第三个是调用写入接口，返回结果后。

然后我们来看看，针对这三个时间点应该如何选择，才能保证数据的一致性：

对于第一个时间点，因为还没有调用写入接口，所以所有线程（包含调用写入的线程）都不应该能够从这个映射中读取到待写入的数据。

第二个时间点，也就是写入操作过程中，我们需要能够保证：如果数据已经被其他线程看到过了，那么再这个时间点之后的所有时间点，数据应该都能够被其他线程看到，也就是说不能出现先被看到但又被删掉的情况。

第三个时间点，这个写入的操作应该能够被所有人看到。


已经定义好了一致性的规范，下面就来看看这个无锁并发的skiplist是如何处理好并发一致性的。

首先我们需要先了解一下链表是如何能够做到无锁写入的：

对于链表类的数据结构来说，如果想做到无锁，主要就是解决以下的问题，如何能够让当前线程知道，目前要插入新元素的位置，是否有其他人正在插入？ 如果有的话，那么就自旋等待，如果没有，那么就插入。利用这个原理，把原来的多步指针变更操作利用compare and set的方式转换为一个伪原子操作。这样就可以有效的减少锁导致的上下文切换开销，在争用不频繁的情况下，极大的提升性能。（这只是思路，关于linkedlist的无锁编程细节，可以参照A pragmatic implementation of non-blocking linked lists，这篇文章）

利用上面链表的无锁写入，我们就能够保证，数据在每一个level内的写是保证无锁写入的。并且，因为每一次有新的数据写入的时候其他尝试写入的线程也都能感知的到，所以这些并行写入的数据可以通过不断相互比较的方式来了解到，自己这个要写入的数据与其他并行写入的数据之间的大小关系，从而可以动态的进行调整以保证在每一层内，数据都是绝对有序的。

同一个level的一致性解决了，那么不同level之间的一致性是如何得到解决的呢？这就与我们刚才定义的一致性规范紧密相关了。因为数据的写入是从低层级开始，一层一层的往更高的层级推送的。而数据读取的时候，则是从最高层级往下读取的。又因为数据是绝对有序的，那么我们就一定可以认为，只要最低层级（level0）内存在了的数据，那么他就一定能够被所有线程看到。而如果在上推的过程中出现了任何异常，其实都是没关系的，因为上推的唯一目的在于加快检索速度，所以就算因为异常没有上推，也只是降低了查询的效率，对数据的可见性完全没有影响。

这个设计确实是非常的巧妙~


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

 

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

第二个优化的思路是如何能够实现一个高性能的随机数算法，这个各位可以自行搜索。

 

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


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

1.       是否支持范围查找

 

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

 

2.       集合是否能够随着数据的增长而自动扩展

 

可以，因为核心数据结构是链表，所以是可以很好的支持数据的不断增长的

 

3.       读写性能如何

 

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

 

4.       是否面向磁盘结构

 

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

因此这个数据结构不适合于磁盘结构。

 

并行指标

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

因此skiplist是个并行度非常高的数据结构。

 

内存占用

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


unsafe_skiplist

[cpp] view plaincopy
  1. #include <iostream>  
  2. #include <stdlib.h>  
  3. #include <time.h>  
  4. using namespace std;  
  5.   
  6. typedef int key_t;  
  7. typedef int value_t;  
  8. #define MAX_LEVEL 16  
  9. #define SKIPLIST_P 0.25  
  10.   
  11. struct node_t {  
  12.     key_t key;  
  13.     value_t val;  
  14.     node_t *forward[];  
  15. };  
  16.   
  17. class SkipList {  
  18.     protected:  
  19.         int m_level;  
  20.         int m_length;  
  21.         node_t *header;  
  22.   
  23.         node_t *creatNode(int level, key_t key, value_t val) {  
  24.             node_t *node = (node_t*)malloc(sizeof(node_t)+level*sizeof(node_t*));  
  25.             if (node == NULL) {  
  26.                 return NULL;  
  27.             }  
  28.             node->key = key;  
  29.             node->val = val;  
  30.             srand(time(NULL));  
  31.             return node;  
  32.         }  
  33.     public:  
  34.         SkipList() {  
  35.             header = creatNode(MAX_LEVEL, 0, 0);  
  36.             if (header == NULL)  
  37.                 exit(-1);  
  38.             m_length = 0;  
  39.             m_level = 0;  
  40.   
  41.             for (int i = 0; i < MAX_LEVEL; ++i) {  
  42.                 header->forward[i] = NULL;  
  43.             }  
  44.         }  
  45.   
  46.         value_t *getValue(key_t key) {  
  47.             int beg = m_level - 1;  
  48.             node_t *p = header;  
  49.             for (; beg >=0; --beg) {  
  50.                   
  51.                 while (p->forward[beg] && p->forward[beg]->key <= key) {  
  52.                     if (p->forward[beg]->key == key)  
  53.                         return &p->forward[beg]->val;  
  54.                     p = p->forward[beg];  
  55.                 }  
  56.                 //p = p->forward[beg-1];  
  57.             }  
  58.   
  59.             return NULL;  
  60.         }  
  61.   
  62.         int randomLevel() {  
  63.             int level = 1;  
  64.             while ((rand()&0xffff) < 0xffff*SKIPLIST_P)  
  65.                 ++level;  
  66.             if(level > MAX_LEVEL) level = MAX_LEVEL;  
  67.             return level;  
  68.         }  
  69.   
  70.         void insert(key_t key, value_t val) {  
  71.             node_t *update[MAX_LEVEL];  
  72.             int beg = m_level - 1;  
  73.             node_t *p = header;  
  74.             node_t *last = NULL;  
  75.             for (; beg >=0; --beg) {  
  76.                 while( (last = p->forward[beg]) && last->key < key) {  
  77.                     p = p->forward[beg];  
  78.                 }  
  79.                 update[beg] = p;  
  80.             }  
  81.   
  82.             if (last && last->key == key) {  
  83.                 last->val = val;  
  84.                 return;  
  85.             }  
  86.   
  87.             m_length++;  
  88.             int level = randomLevel();  
  89.               
  90.             if (level > m_level) {  
  91.                 for(int i = m_level; i < level; ++i)  
  92.                     update[i] = header;  
  93.                 m_level = level;  
  94.             }  
  95.             node_t *node = creatNode(level, key, val);  
  96.             for (beg = level - 1; beg >=0; --beg) {  
  97.                 node->forward[beg] = update[beg]->forward[beg];  
  98.                 update[beg]->forward[beg] = node;  
  99.             }  
  100.   
  101.   
  102.         }  
  103.   
  104.         void erase(key_t key) {  
  105.             node_t *update[MAX_LEVEL];  
  106.             int beg = m_level - 1;  
  107.             node_t *p = header;  
  108.             node_t *last = NULL;  
  109.   
  110.             for (; beg >=0; --beg) {  
  111.                 while ((last = p->forward[beg]) && last->key < key) {  
  112.                     p = p->forward[beg];  
  113.                 }  
  114.             }  
  115.   
  116.             if (last && last->key != key)  
  117.                 return;  
  118.   
  119.             for (beg = m_level; beg >=0; --beg) {  
  120.                 if (update[beg]->forward[beg] == last){  
  121.                     update[beg]->forward[beg] = last->forward[beg];  
  122.                     if (header->forward[beg] == NULL)  
  123.                         m_level--;  
  124.                 }  
  125.             }  
  126.   
  127.             free(last);  
  128.   
  129.             m_length--;  
  130.         }  
  131.   
  132.         void display() {  
  133.             node_t *p = header->forward[0];  
  134.             while (p) {  
  135.                 cout << p->key << ":"<<p->val<<" ";  
  136.                 p = p->forward[0];  
  137.             }  
  138.   
  139.             cout <<endl;  
  140.          
  141.         }  
  142.   
  143.         ~SkipList() {  
  144.             node_t *p = header;  
  145.             while (p){  
  146.                 node_t *next = p->forward[0];  
  147.                 free(p);  
  148.                 p = next;  
  149.             }      
  150.         }  
  151.   
  152.   
  153. };  
  154.   
  155. int main() {  
  156.     SkipList sl;  
  157.     /*for (int i = 0; i < 1000; ++i){ 
  158.         cout << i <<endl; 
  159.         sl.insert(rand(),i); 
  160.     }*/  
  161.     sl.insert(0,10);  
  162.     sl.insert(5, 50);  
  163.     sl.insert(6, 60);  
  164.     sl.insert(0, 11);  
  165.     sl.insert(5, 51);  
  166.     sl.insert(7,70);  
  167.   
  168.     sl.insert(3, 30);  
  169.     sl.insert(4,40);  
  170.     sl.insert(3,31);  
  171.     sl.display();  
  172.     return 1;  
  173. }  
posted @ 2015-05-13 18:55  懒人部落  阅读(316)  评论(0)  编辑  收藏  举报