深刻理解Redis跳躍表的基本實現和特性

點贊再看，養成習慣，公衆號搜一搜【一角錢技術】關注更多原創技術文章。本文 GitHub org_hejianhui/JavaStudy 已收錄，有個人系列文章。html

前言

在這裏咱們先回憶一下普通鏈表的時間複雜度，能夠看到除了 look up 操做是 $O(n)$ 的，其餘操做都是 $O(1)$ 的時間複雜度。也就是說你須要隨機訪問裏面的任何一個元素的話，它的時間複雜度平均值是 $O(n)$ 的，這也就是鏈表它的問題所在。從這裏能夠看到並無所謂完美的一種數據結構，若是完美那就不須要 Array 或者 LInked List 這兩個數據結構並存了，就直接使用最牛逼的數據結構便可。因此至關於各有優劣，看你的使用場景在什麼地方，做爲完整性比較，我這裏把兩種時間複雜度都列出來。java

Linked List 的時間複雜度 node

Array 的時間複雜度 git

注意：正常狀況下數組的 prepend 操做的時間複雜度是 O(n) ，可是能夠進行特殊優化到 O(1)。採用的方式是申請稍微大一些的內存空間，而後在數組開始預留一部分空間，而後 prepend 的操做則是把頭下標前移一個位置便可。github

跳錶 Skip List

前面回顧了 Array 和 Linked List 的兩種結構的時間複雜度，有一種狀況下鏈表它的速度在 $O(n)$ 這一塊，就會以爲不太夠用，咱們來看一下這種狀況指的是什麼？面試

鏈表元素有序的時候

注意是指整個元素，若是是有序的話，在有些時候，好比在數據庫裏面也好，或者是在其餘對一些有序的樹進行查詢的時候，即便用鏈表這種方式存儲的話，咱們發現它的元素是有序的，好比說下面這個升序鏈表，134578910 它是升序排列的，這個時候咱們要快速地查詢，好比 9 在什麼地方或者查詢 5，是否是在這個鏈表裏面出現，這時候你會發現，若是是用普通的數組能夠進行二分查找能夠很快查到5所在的位置，以及查詢到一個元素是否存在。redis

一個有序的數組裏面存在，那麼問題來了，若是是有序的，可是是鏈表的狀況下應該怎樣有效地加速呢？因而在近代1990年先後，一種新的數據結構出現了，它的名字叫作跳錶。數據庫

跳錶的特色

注意：只能用於元素有序的狀況。數組

因此，跳錶（skip list）對錶的是平衡樹（AVL Tree）和二分查找，是一種插入/刪除/搜索都是 $O(log n)$ 的數據結構。1989 年出現。markdown

無論是平衡樹、二叉搜索樹其餘哪些樹的話都是在1960年和196幾年就已經出現了，它的出現比平衡樹和二分查找以及所謂的一些高級數據結構出現的要晚。比其餘的晚了接近30年，最後纔出現，這就是爲何不少老的數據結構的話，用平衡二叉樹會多一點，而一些比較新的，特別是在元素個數很少的狀況的狀況下，用的所有都是跳錶，也就是說在更新換代了。

它的最大優點是原理簡單、容易實現、方便擴展、效率更高。所以在一些熱門的項目裏用來替代平衡樹，如 Redis、LevelDB等。

跳躍表（skiplist）是一種隨機化的數據，由 William Pugh 在論文《Skip lists: a probabilistic alternative to balanced trees》中提出，跳躍表以有序的方式在層次化的鏈表中保存元素，效率和平衡樹媲美 —— 查找、刪除、添加等操做均可以在對數指望時間下完成，而且比起平衡樹來講，跳躍表的實現要簡單直觀得多。

如何給有序的鏈表加速

假設有一個有序的鏈表，1 3 4 5 7 8 9 10 這麼一個原始的鏈表。它的時間複雜度查詢確定是 $O(n)$ 的，那麼問一下如何優化？如何進行簡單優化？可讓它的查詢時間複雜度變低，也就是加速它的查詢。

咱們能夠思考一些，若是你來好比說我要很快地查到 7 ，有沒有在鏈表中存在和它的位置在哪兒的話，你可以很是快的查詢出來嗎？

時間複雜度：查詢 O(n)
簡單優化：添加頭尾指針

上面這麼一個結構，它是一維的數據結構，如今它是有序了，也就是說咱們有附加的信息了，那麼如何加速對吧？通常來講這種加速的方式的話，就相似於星際穿越裏面這有點玄學，可是你必定要記住一個概念就好了，一維的數據結構要加速的話，常常採用的方式就是升維也就是說變成二維。爲何要多一層維度，由於你多了一個維度以後，就會有多一級的信息在裏面，這樣多一級的信息就能夠幫助你能夠很快地獲得一維裏面你必須挨個走才能走到的那些元素

添加第一級索引

如何提升鏈表線性查找的效率？具體咱們來看上圖，在原始鏈表的狀況下，咱們再增長一個維度，也就是在上面再增長一層索引，咱們叫作第一級索引，那麼第一級索引的話就不是指向它元素的 next 元素了，而是指向它的 next next ，也就是說你能夠理解爲 next + 1 就好了，因此第一級索引的話就是第一個元素，立刻第三個元素、第五個元素、第七個元素。

這裏你就會發現若是你要找7的話，咱們怎麼辦？咱們這麼查找，先查找第一級索引看有沒有1 4 7 ，若是有那就說明 7 存在這個鏈表裏面是存在的，說明咱們查詢到了。
咱們再看要查另外一個元素，好比說 8，咱們怎麼走？仍是先找第一級，8是大於 1 的，因此後繼日後到達 4 索引的值，8 是大於 4的，繼續日後到了7，8 也大於7的，再繼續日後發現 9 大於 8 了。說明 8 是存在於 7 和 9 這兩個索引之間的元素裏面的，那麼這個時候從第一級元素向下走到原始的鏈表了，從對應的位置挨個找就會發現 8 找到了，說明 8 也是存在的。

添加第二級索引

那麼有的朋友可能就會想了，你加一級索引的話，每次至關於步伐加 2 了，可是它的速度的話也就是比原來稍微快了一點，能不能更快呢？對你這個想法是很是有道理的，也是很好的。

那麼在一級索引的基礎上，咱們能夠再加索引就好了，也就是說同理可得，在第一級索引的基礎上，咱們把它看成是一個原始鏈表同樣，往上再加一級索引，也就是說每次針對第一級索引走兩步。那麼它相等於原始鏈表至關於每次就走了四步。對不對，就乘於 2，那這樣的話，速度就更加高效了。

好比我舉個例子要查8，先找 1，8 比 1要大，再找 7 ，這時候你會發現 8 也是比 7 大的，再找，假設這個元素後面的話是 11 或者 12 好了，這時候你會發現 8 是小於它後面的元素，因此 7 這裏的話就必須向下再走一級索引了，走到第一級索引的 7 來，再相似於以前 7 和 9 之間，而後再走到8 這樣一直走下來。

添加多級索引

以此類推，增長多級索引

假設有五級索引的這麼一個原始鏈表，那麼咱們要查一個元素，好比說要查 62 元素或者中間元素，就相似於下圖，一級一級一級一級走下來，最後的話就能夠查到咱們須要的62這個元素。固然的話你最後查到原始鏈表，你會發現好比說是咱們要查63或者61，原始鏈表裏面沒有，咱們就說元素不存在，在咱們這個有序的鏈表裏面，也就是說在跳錶裏面查不到這麼一個元素，最後也能夠得出這樣的結論。

跳錶查詢的時間複雜度分析

跳錶的時間複雜度計算

n/二、n/四、n/八、第 k 級索引結點的個數就是 n/(2^k)
假設索引有 h 級，最高級的索引有 2 個結點。n/(2^h) = 2，從而求得 h = log2(n)-1

舉一個例子，跳錶在查詢的時候，假設索引的高度：logn，每層索引遍歷的結點個數：3，假設要走到第 8 個節點。

每層要遍歷的元素總共是3個，因此這裏的話 log28 的話，就是它的時間複雜度。最後的話得出證實出來：時間複雜度爲log2n。也就是從最樸素的原始鏈表的話，它的 O(n) 的時間複雜度降到 log2n 的時間複雜度。這已是一個很大的改進了。假設是1024的話，你會發現原始鏈表要查1024次最後獲得這個元素，那麼這裏的話就只須要查（2的10次方是1024次）十次這樣一個數量級。

現實中跳錶的形態

在現實中咱們在用跳錶的狀況下，它會因爲這個元素的增長和刪除而致使的它的索引的話，有些數它並非徹底很是工整的，最後通過屢次改動後，它最後索引有些地方會跨幾步，有些地方會少只跨兩步，這是由於裏面的一些元素會被增長和刪除了，並且它的維護成本相對較高，也是說當你增長一個元素，你會把它的索引要更新一遍，你要刪除一個元素，也須要把它的索引更新一遍。在這種過程當中它在增長和刪除的話，它的時間複雜度就會變成 $O(logn)$ 了。

在跳錶中查詢任意數據的時平均時間複雜度就是 O(logn)。

跳錶查詢的空間複雜度分析

在這裏的話，咱們假設它的長度爲 n，而後按照以前的例子，每兩個節點抽一個作成一個索引的話，那麼它的一級索引爲二分之 n 對吧。最後以下：

原始鏈表大小爲 n，每 2 個結點抽 1 個，每層索引的結點數: $\frac{n}{2},\frac{n}{4},\frac{n}{8}...,8,4,2$
原始鏈表大小爲 n，每 3 個結點抽 1 個，每層索引的結點數: $\frac{n}{3},\frac{n}{9},\frac{n}{27}...,9,3,1$
空間複雜度是 $O(n)$

跳躍表的構成

如下是個典型的跳躍表例子：從圖中能夠看到，跳躍表主要由如下部分構成：

表頭（head）：負責維護跳躍表的節點指針。
跳躍表節點：保存着元素值，以及多個層。
層：保存着指向其餘元素的指針。高層的指針越過的元素數量大於等於低層的指針，爲了提升查找的效率，程序老是從高層先開始訪問，而後隨着元素值範圍的縮小，慢慢下降層次。
表尾：所有由 NULL 組成，表示跳躍表的末尾。

Redis 跳躍表的實現

Redis 的跳躍表由 redis.h/zskiplistNode 和 redis.h/zskiplist 兩個結構定義，其中 zskiplistNode 結構用於表示跳躍表節點，而 zskiplist 結構則用於保存跳躍表節點的相關信息，好比節點的數量，以及指向表頭節點和表尾節點的指針，等等。上圖展現了一個跳躍表示例，位於圖片最左邊的示 zskiplist 結構，該結構包含如下屬性：

header ：指向跳躍表的表頭節點。
tail ：指向跳躍表的表尾節點。
level ：記錄目前跳躍表內，層數最大的那個節點的層數（表頭節點的層數不計算在內）。
length ：記錄跳躍表的長度，也便是，跳躍表目前包含節點的數量（表頭節點不計算在內）。

位於 zskiplist 結構右方的是四個 zskiplistNode 結構，該結構包含如下屬性：

層（level）：節點中用 L1 、 L2 、 L3 等字樣標記節點的各個層， L1 表明第一層， L2 表明第二層，以此類推。每一個層都帶有兩個屬性：前進指針和跨度。前進指針用於訪問位於表尾方向的其餘節點，而跨度則記錄了前進指針所指向節點和當前節點的距離。在上面的圖片中，連線上帶有數字的箭頭就表明前進指針，而那個數字就是跨度。當程序從表頭向表尾進行遍歷時，訪問會沿着層的前進指針進行。
後退（backward）指針：節點中用 BW 字樣標記節點的後退指針，它指向位於當前節點的前一個節點。後退指針在程序從表尾向表頭遍歷時使用。
分值（score）：各個節點中的 1.0 、 2.0 和 3.0 是節點所保存的分值。在跳躍表中，節點按各自所保存的分值從小到大排列。
成員對象（obj）：各個節點中的 o1 、 o2 和 o3 是節點所保存的成員對象。

注意：表頭節點和其餘節點的構造是同樣的：表頭節點也有後退指針、分值和成員對象，不過表頭節點的這些屬性都不會被用到，因此圖中省略了這些部分，只顯示了表頭節點的各個層。

跳躍表節點

跳躍表節點的實現由 redis.h/zskiplistNode 結構定義：

typedef struct zskiplistNode {
    // 後退指針
    struct zskiplistNode *backward;
    // 分值
    double score;
    // 成員對象
    robj *obj;
    // 層
    struct zskiplistLevel {
        // 前進指針
        struct zskiplistNode *forward;
        // 跨度
        unsigned int span;
    } level[];
} zskiplistNode;
複製代碼

層

跳躍表節點的 level 數組能夠包含多個元素，每一個元素都包含一個指向其餘節點的指針，程序能夠經過這些層來加快訪問其餘節點的速度，通常來講，層的數量越多，訪問其餘節點的速度就越快。

每次建立一個新跳躍表節點的時候，程序都根據冪次定律（power law，越大的數出現的機率越小）隨機生成一個介於 1 和 32 之間的值做爲 level 數組的大小，這個大小就是層的「高度」。

下圖分別展現了三個高度爲 1 層、 3 層和 5 層的節點，由於 C 語言的數組索引老是從 0 開始的，因此節點的第一層是 level[0] ，而第二層是 level[1] ，以此類推。

前進指針

每一個層都有一個指向表尾方向的前進指針（level[i].forward 屬性），用於從表頭向表尾方向訪問節點。上圖用虛線表示出了程序從表頭向表尾方向，遍歷跳躍表中全部節點的路徑：

迭代程序首先訪問跳躍表的第一個節點（表頭），而後從第四層的前進指針移動到表中的第二個節點。
在第二個節點時，程序沿着第二層的前進指針移動到表中的第三個節點。
在第三個節點時，程序一樣沿着第二層的前進指針移動到表中的第四個節點。
當程序再次沿着第四個節點的前進指針移動時，它碰到一個 NULL ，程序知道這時已經到達了跳躍表的表尾，因而結束此次遍歷。

跨度

層的跨度（level[i].span 屬性）用於記錄兩個節點之間的距離：

兩個節點之間的跨度越大，它們相距得就越遠。
指向 NULL 的全部前進指針的跨度都爲 0 ，由於它們沒有連向任何節點。

初看上去，很容易覺得跨度和遍歷操做有關，但實際上並非這樣 —— 遍歷操做只使用前進指針就能夠完成了，跨度其實是用來計算排位（rank）的：在查找某個節點的過程當中，將沿途訪問過的全部層的跨度累計起來，獲得的結果就是目標節點在跳躍表中的排位。

舉個例子，以下用虛線標記了在跳躍表中查找分值爲 3.0 、成員對象爲 o3 的節點時，沿途經歷的層：查找的過程只通過了一個層，而且層的跨度爲 3 ，因此目標節點在跳躍表中的排位爲 3 。

再舉個例子，以下用虛線標記了在跳躍表中查找分值爲 2.0 、成員對象爲 o2 的節點時，沿途經歷的層：在查找節點的過程當中，程序通過了兩個跨度爲 1 的節點，所以能夠計算出，目標節點在跳躍表中的排位爲 2 。

後退指針

節點的後退指針（backward 屬性）用於從表尾向表頭方向訪問節點：跟能夠一次跳過多個節點的前進指針不一樣，由於每一個節點只有一個後退指針，因此每次只能後退至前一個節點。上圖用虛線展現了若是從表尾向表頭遍歷跳躍表中的全部節點：程序首先經過跳躍表的 tail 指針訪問表尾節點，而後經過後退指針訪問倒數第二個節點，以後再沿着後退指針訪問倒數第三個節點，再以後遇到指向 NULL 的後退指針，因而訪問結束。

分值和成員

節點的分值（score 屬性）是一個 double 類型的浮點數，跳躍表中的全部節點都按分值從小到大來排序。
節點的成員對象（obj 屬性）是一個指針，它指向一個字符串對象，而字符串對象則保存着一個 SDS（簡單動態字符串）值。

在同一個跳躍表中，各個節點保存的成員對象必須是惟一的，可是多個節點保存的分值卻能夠是相同的：分值相同的節點將按照成員對象在字典序中的大小來進行排序，成員對象較小的節點會排在前面（靠近表頭的方向），而成員對象較大的節點則會排在後面（靠近表尾的方向）。

舉個例子，在下圖所示的跳躍表中，三個跳躍表節點都保存了相同的分值 10086.0 ，但保存成員對象 o1 的節點卻排在保存成員對象 o2 和 o3 的節點以前，而保存成員對象 o2 的節點又排在保存成員對象 o3 的節點以前，因而可知， o1 、 o2 、 o3 三個成員對象在字典中的排序爲 o1 <= o2 <= o3 。

跳躍表

雖然僅靠多個跳躍表節點就能夠組成一個跳躍表，以下圖所示：但經過使用一個 zskiplist 結構來持有這些節點，程序能夠更方便地對整個跳躍表進行處理，好比快速訪問跳躍表的表頭節點和表尾節點，又或者快速地獲取跳躍表節點的數量（也便是跳躍表的長度）等信息，以下所示： zskiplist 結構的定義以下：

typedef struct zskiplist {

    // 表頭節點和表尾節點
    struct zskiplistNode *header, *tail;

    // 表中節點的數量
    unsigned long length;

    // 表中層數最大的節點的層數
    int level;

} zskiplist;
複製代碼

header 和 tail 指針分別指向跳躍表的表頭和表尾節點，經過這兩個指針，程序定位表頭節點和表尾節點的複雜度爲 O(1) 。
經過使用 length 屬性來記錄節點的數量，程序能夠在 O(1) 複雜度內返回跳躍表的長度。
level 屬性則用於在 O(1) 複雜度內獲取跳躍表中層高最大的那個節點的層數量，注意表頭節點的層高並不計算在內。

跳躍表API

列出了跳躍表的全部操做 API 。

函數	做用	時間複雜度
`zslCreate`	建立一個新的跳躍表。	O(1)
`zslFree`	釋放給定跳躍表，以及表中包含的全部節點。	O(N) ， `N` 爲跳躍表的長度。
`zslInsert`	將包含給定成員和分值的新節點添加到跳躍表中。	平均 O(\log N) ，最壞 O(N) ， `N` 爲跳躍表長度。
`zslDelete`	刪除跳躍表中包含給定成員和分值的節點。	平均 O(\log N) ，最壞 O(N) ， `N` 爲跳躍表長度。
`zslGetRank`	返回包含給定成員和分值的節點在跳躍表中的排位。	平均 O(\log N) ，最壞 O(N) ， `N` 爲跳躍表長度。
`zslGetElementByRank`	返回跳躍表在給定排位上的節點。	平均 O(\log N) ，最壞 O(N) ， `N` 爲跳躍表長度。
`zslIsInRange`	給定一個分值範圍（range），好比 `0` 到 `15` ， `20` 到 `28` ，諸如此類，若是給定的分值範圍包含在跳躍表的分值範圍以內，那麼返回 `1` ，不然返回 `0` 。	經過跳躍表的表頭節點和表尾節點，這個檢測能夠用 O(1) 複雜度完成。
`zslFirstInRange`	給定一個分值範圍，返回跳躍表中第一個符合這個範圍的節點。	平均 O(\log N) ，最壞 O(N) 。 `N` 爲跳躍表長度。
`zslLastInRange`	給定一個分值範圍，返回跳躍表中最後一個符合這個範圍的節點。	平均 O(\log N) ，最壞 O(N) 。 `N` 爲跳躍表長度。
`zslDeleteRangeByScore`	給定一個分值範圍，刪除跳躍表中全部在這個範圍以內的節點。	O(N) ， `N` 爲被刪除節點數量。
`zslDeleteRangeByRank`	給定一個排位範圍，刪除跳躍表中全部在這個範圍以內的節點。	O(N) ， `N` 爲被刪除節點數量。

面試：爲啥 redis 使用跳錶(skiplist)而不是使用 red-black？

skiplist的複雜度和紅黑樹同樣，並且實現起來更簡單。
在併發環境下skiplist有另一個優點，紅黑樹在插入和刪除的時候可能須要作一些rebalance的操做，這樣的操做可能會涉及到整個樹的其餘部分，而skiplist的操做顯然更加局部性一些，鎖須要盯住的節點更少，所以在這樣的狀況下性能好一些。

具體能夠參考Herb Sutter寫的Choose Concurrency-Friendly Data Structures.

另外這篇論文裏有更詳細的說明和對比，page50~53： www.cl.cam.ac.uk/research/sr…

附：開發者說的爲何選用skiplist The Skip list

There are a few reasons:

They are not very memory intensive. It's up to you basically. Changing parameters about the probability of a node to have a given number of levels will make then less memory intensive than btrees.

A sorted set is often target of many ZRANGE or ZREVRANGE operations, that is, traversing the skip list as a linked list. With this operation the cache locality of skip lists is at least as good as with other kind of balanced trees.

They are simpler to implement, debug, and so forth. For instance thanks to the skip list simplicity I received a patch (already in Redis master) with augmented skip lists implementing ZRANK in O(log(N)). It required little changes to the code.

About the Append Only durability & speed, I don't think it is a good idea to optimize Redis at cost of more code and more complexity for a use case that IMHO should be rare for the Redis target (fsync() at every command). Almost no one is using this feature even with ACID SQL databases, as the performance hint is big anyway.

About threads: our experience shows that Redis is mostly I/O bound. I'm using threads to serve things from Virtual Memory. The long term solution to exploit all the cores, assuming your link is so fast that you can saturate a single core, is running multiple instances of Redis (no locks, almost fully scalable linearly with number of cores), and using the "Redis Cluster" solution that I plan to develop in the future.

總結

跳躍表是有序集合的底層實現之一，除此以外它在 Redis 中沒有其餘應用。
Redis 的跳躍表實現由 zskiplist 和 zskiplistNode 兩個結構組成，其中 zskiplist 用於保存跳躍表信息（好比表頭節點、表尾節點、長度），而 zskiplistNode 則用於表示跳躍表節點。
每一個跳躍表節點的層高都是 1 至 32 之間的隨機數。
在同一個跳躍表中，多個節點能夠包含相同的分值，但每一個節點的成員對象必須是惟一的。
跳躍表中的節點按照分值大小進行排序，當分值相同時，節點按照成員對象的大小進行排序。

參考資料

跳躍表

文章持續更新，能夠公衆號搜一搜「一角錢技術」第一時間閱讀，本文 GitHub org_hejianhui/JavaStudy 已經收錄，歡迎 Star。