本文轉自網際網路

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章首發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《探索Redis設計與實現》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從入門到進階，Redis基本的使用方法，Redis的基本資料結構，以及一些進階的使用方法，同時也需要進一步瞭解Redis的底層資料結構，再接著，還會帶來Redis主從複製、叢集、分散式鎖等方面的相關內容，以及作為快取的一些使用方法和注意事項，以便讓你更完整地瞭解整個Redis相關的技術體系，形成自己的知識框架。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

如果你使用過Redis，一定會像我一樣對它的內部實現產生興趣。《Redis內部資料結構詳解》是我準備寫的一個系列，也是我個人對於之前研究Redis的一個階段性總結，著重講解Redis在記憶體中的資料結構實現（暫不涉及持久化的話題）。Redis本質上是一個資料結構伺服器（data structures server），以高效的方式實現了多種現成的資料結構，研究它的資料結構和基於其上的演算法，對於我們自己提升區域性演算法的程式設計水平有很重要的參考意義。

當我們在本文中提到Redis的“資料結構”，可能是在兩個不同的層面來討論它。

第一個層面，是從使用者的角度。比如：

*   string
*   list
*   hash
*   set
*   sorted set

這一層面也是Redis暴露給外部的呼叫介面。

第二個層面，是從內部實現的角度，屬於更底層的實現。比如：

*   dict
*   sds
*   ziplist
*   quicklist
*   skiplist

第一個層面的“資料結構”，Redis的官方文件([http://redis.io/topics/data-types-intro](http://redis.io/topics/data-types-intro))有詳細的介紹。本文的重點在於討論第二個層面，Redis資料結構的內部實現，以及這兩個層面的資料結構之間的關係：Redis如何透過組合第二個層面的各種基礎資料結構來實現第一個層面的更高層的資料結構。

在討論任何一個系統的內部實現的時候，我們都要先明確它的設計原則，這樣我們才能更深刻地理解它為什麼會進行如此設計的真正意圖。在本文接下來的討論中，我們主要關注以下幾點：

*   儲存效率（memory efficiency）。Redis是專用於儲存資料的，它對於計算機資源的主要消耗就在於記憶體，因此節省記憶體是它非常非常重要的一個方面。這意味著Redis一定是非常精細地考慮了壓縮資料、減少記憶體碎片等問題。
*   快速響應時間（fast response time）。與快速響應時間相對的，是高吞吐量（high throughput）。Redis是用於提供線上訪問的，對於單個請求的響應時間要求很高，因此，快速響應時間是比高吞吐量更重要的目標。有時候，這兩個目標是矛盾的。
*   單執行緒（single-threaded）。Redis的效能瓶頸不在於CPU資源，而在於記憶體訪問和網路IO。而採用單執行緒的設計帶來的好處是，極大簡化了資料結構和演算法的實現。相反，Redis透過非同步IO和pipelining等機制來實現高速的併發訪問。顯然，單執行緒的設計，對於單個請求的快速響應時間也提出了更高的要求。

本文是《Redis內部資料結構詳解》系列的第一篇，講述Redis一個重要的基礎資料結構：dict。

dict是一個用於維護key和value對映關係的資料結構，與很多語言中的Map或dictionary類似。Redis的一個database中所有key到value的對映，就是使用一個dict來維護的。不過，這只是它在Redis中的一個用途而已，它在Redis中被使用的地方還有很多。比如，一個Redis hash結構，當它的field較多時，便會採用dict來儲存。再比如，Redis配合使用dict和skiplist來共同維護一個sorted set。這些細節我們後面再討論，在本文中，我們集中精力討論dict本身的實現。

dict本質上是為了解決演算法中的查詢問題（Searching），一般查詢問題的解法分為兩個大類：一個是基於各種平衡樹，一個是基於雜湊表。我們平常使用的各種Map或dictionary，大都是基於雜湊表實現的。在不要求資料有序儲存，且能保持較低的雜湊值衝突機率的前提下，基於雜湊表的查詢效能能做到非常高效，接近O(1)，而且實現簡單。

在Redis中，dict也是一個基於雜湊表的演算法。和傳統的雜湊演算法類似，它採用某個雜湊函式從key計算得到在雜湊表中的位置，採用拉鍊法解決衝突，並在裝載因子（load factor）超過預定值時自動擴充套件記憶體，引發重雜湊（rehashing）。Redis的dict實現最顯著的一個特點，就在於它的重雜湊。它採用了一種稱為增量式重雜湊（incremental rehashing）的方法，在需要擴充套件記憶體時避免一次性對所有key進行重雜湊，而是將重雜湊操作分散到對於dict的各個增刪改查的操作中去。這種方法能做到每次只對一小部分key進行重雜湊，而每次重雜湊之間不影響dict的操作。dict之所以這樣設計，是為了避免重雜湊期間單個請求的響應時間劇烈增加，這與前面提到的“快速響應時間”的設計原則是相符的。

下面進行詳細介紹。

#### dict的資料結構定義

為了實現增量式重雜湊（incremental rehashing），dict的資料結構裡包含兩個雜湊表。在重雜湊期間，資料從第一個雜湊表向第二個雜湊表遷移。

dict的C程式碼定義如下（出自Redis原始碼dict.h）：
    
    typedef struct dictEntry {
        void *key;
        union {
            void *val;
            uint64_t u64;
            int64_t s64;
            double d;
        } v;
        struct dictEntry *next;
    } dictEntry;
    
    typedef struct dictType {
        unsigned int (*hashFunction)(const void *key);
        void *(*keyDup)(void *privdata, const void *key);
        void *(*valDup)(void *privdata, const void *obj);
        int (*keyCompare)(void *privdata, const void *key1, const void *key2);
        void (*keyDestructor)(void *privdata, void *key);
        void (*valDestructor)(void *privdata, void *obj);
    } dictType;
    
    /* This is our hash table structure. Every dictionary has two of this as we
     * implement incremental rehashing, for the old to the new table. */
    typedef struct dictht {
        dictEntry **table;
        unsigned long size;
        unsigned long sizemask;
        unsigned long used;
    } dictht;
    
    typedef struct dict {
        dictType *type;
        void *privdata;
        dictht ht[2];
        long rehashidx; /* rehashing not in progress if rehashidx == -1 */
        int iterators; /* number of iterators currently running */
    } dict;

為了能更清楚地展示dict的資料結構定義，我們用一張結構圖來表示它。如下。

[![Redis dict結構圖](http://zhangtielei.com/assets/photos_redis/redis_dict_structure.png)](http://zhangtielei.com/assets/photos_redis/redis_dict_structure.png)

結合上面的程式碼和結構圖，可以很清楚地看出dict的結構。一個dict由如下若干項組成：

*   一個指向dictType結構的指標（type）。它透過自定義的方式使得dict的key和value能夠儲存任何型別的資料。
*   一個私有資料指標（privdata）。由呼叫者在建立dict的時候傳進來。
*   兩個雜湊表（ht[2]）。只有在重雜湊的過程中，ht[0]和ht[1]才都有效。而在平常情況下，只有ht[0]有效，ht[1]裡面沒有任何資料。上圖表示的就是重雜湊進行到中間某一步時的情況。
*   當前重雜湊索引（rehashidx）。如果rehashidx = -1，表示當前沒有在重雜湊過程中；否則，表示當前正在進行重雜湊，且它的值記錄了當前重雜湊進行到哪一步了。
*   當前正在進行遍歷的iterator的個數。這不是我們現在討論的重點，暫時忽略。

dictType結構包含若干函式指標，用於dict的呼叫者對涉及key和value的各種操作進行自定義。這些操作包含：

*   hashFunction，對key進行雜湊值計算的雜湊演算法。
*   keyDup和valDup，分別定義key和value的複製函式，用於在需要的時候對key和value進行深複製，而不僅僅是傳遞物件指標。
*   keyCompare，定義兩個key的比較操作，在根據key進行查詢時會用到。
*   keyDestructor和valDestructor，分別定義對key和value的解構函式。

私有資料指標（privdata）就是在dictType的某些操作被呼叫時會傳回給呼叫者。

需要詳細察看的是dictht結構。它定義一個雜湊表的結構，由如下若干項組成：

*   一個dictEntry指標陣列（table）。key的雜湊值最終對映到這個陣列的某個位置上（對應一個bucket）。如果多個key對映到同一個位置，就發生了衝突，那麼就拉出一個dictEntry連結串列。
*   size：標識dictEntry指標陣列的長度。它總是2的指數。
*   sizemask：用於將雜湊值對映到table的位置索引。它的值等於(size-1)，比如7, 15, 31, 63，等等，也就是用二進位制表示的各個bit全1的數字。每個key先經過hashFunction計算得到一個雜湊值，然後計算(雜湊值 & sizemask)得到在table上的位置。相當於計算取餘(雜湊值 % size)。
*   used：記錄dict中現有的資料個數。它與size的比值就是裝載因子（load factor）。這個比值越大，雜湊值衝突機率越高。

dictEntry結構中包含k, v和指向連結串列下一項的next指標。k是void指標，這意味著它可以指向任何型別。v是個union，當它的值是uint64_t、int64_t或double型別時，就不再需要額外的儲存，這有利於減少記憶體碎片。當然，v也可以是void指標，以便能儲存任何型別的資料。

#### dict的建立（dictCreate）

dict *dictCreate(dictType *type,
            void *privDataPtr)
    {
        dict *d = zmalloc(sizeof(*d));
    
        _dictInit(d,type,privDataPtr);
        return d;
    }
    
    int _dictInit(dict *d, dictType *type,
            void *privDataPtr)
    {
        _dictReset(&d->ht[0]);
        _dictReset(&d->ht[1]);
        d->type = type;
        d->privdata = privDataPtr;
        d->rehashidx = -1;
        d->iterators = 0;
        return DICT_OK;
    }
    
    static void _dictReset(dictht *ht)
    {
        ht->table = NULL;
        ht->size = 0;
        ht->sizemask = 0;
        ht->used = 0;
    }

dictCreate為dict的資料結構分配空間併為各個變數賦初值。其中兩個雜湊表ht[0]和ht[1]起始都沒有分配空間，table指標都賦為NULL。這意味著要等第一個資料插入時才會真正分配空間。

#### dict的查詢（dictFind）
    
    #define dictIsRehashing(d) ((d)->rehashidx != -1)
    
    dictEntry *dictFind(dict *d, const void *key)
    {
        dictEntry *he;
        unsigned int h, idx, table;
    
        if (d->ht[0].used + d->ht[1].used == 0) return NULL; /* dict is empty */
        if (dictIsRehashing(d)) _dictRehashStep(d);
        h = dictHashKey(d, key);
        for (table = 0; table <= 1; table++) {
            idx = h & d->ht[table].sizemask;
            he = d->ht[table].table[idx];
            while(he) {
                if (key==he->key || dictCompareKeys(d, key, he->key))
                    return he;
                he = he->next;
            }
            if (!dictIsRehashing(d)) return NULL;
        }
        return NULL;
    }

上述dictFind的原始碼，根據dict當前是否正在重雜湊，依次做了這麼幾件事：

*   如果當前正在進行重雜湊，那麼將重雜湊過程向前推進一步（即呼叫_dictRehashStep）。實際上，除了查詢，插入和刪除也都會觸發這一動作。這就將重雜湊過程分散到各個查詢、插入和刪除操作中去了，而不是集中在某一個操作中一次性做完。
*   計算key的雜湊值（呼叫dictHashKey，裡面的實現會呼叫前面提到的hashFunction）。
*   先在第一個雜湊表ht[0]上進行查詢。在table陣列上定位到雜湊值對應的位置（如前所述，透過雜湊值與sizemask進行按位與），然後在對應的dictEntry連結串列上進行查詢。查詢的時候需要對key進行比較，這時候呼叫dictCompareKeys，它裡面的實現會呼叫到前面提到的keyCompare。如果找到就返回該項。否則，進行下一步。
*   判斷當前是否在重雜湊，如果沒有，那麼在ht[0]上的查詢結果就是最終結果（沒找到，返回NULL）。否則，在ht[1]上進行查詢（過程與上一步相同）。

下面我們有必要看一下增量式重雜湊的_dictRehashStep的實現。

static void _dictRehashStep(dict *d) {
        if (d->iterators == 0) dictRehash(d,1);
    }
    
    int dictRehash(dict *d, int n) {
        int empty_visits = n*10; /* Max number of empty buckets to visit. */
        if (!dictIsRehashing(d)) return 0;
    
        while(n-- && d->ht[0].used != 0) {
            dictEntry *de, *nextde;
    
            /* Note that rehashidx can't overflow as we are sure there are more
             * elements because ht[0].used != 0 */
            assert(d->ht[0].size > (unsigned long)d->rehashidx);
            while(d->ht[0].table[d->rehashidx] == NULL) {
                d->rehashidx++;
                if (--empty_visits == 0) return 1;
            }
            de = d->ht[0].table[d->rehashidx];
            /* Move all the keys in this bucket from the old to the new hash HT */
            while(de) {
                unsigned int h;
    
                nextde = de->next;
                /* Get the index in the new hash table */
                h = dictHashKey(d, de->key) & d->ht[1].sizemask;
                de->next = d->ht[1].table[h];
                d->ht[1].table[h] = de;
                d->ht[0].used--;
                d->ht[1].used++;
                de = nextde;
            }
            d->ht[0].table[d->rehashidx] = NULL;
            d->rehashidx++;
        }
    
        /* Check if we already rehashed the whole table... */
        if (d->ht[0].used == 0) {
            zfree(d->ht[0].table);
            d->ht[0] = d->ht[1];
            _dictReset(&d->ht[1]);
            d->rehashidx = -1;
            return 0;
        }
    
        /* More to rehash... */
        return 1;
    }

dictRehash每次將重雜湊至少向前推進n步（除非不到n步整個重雜湊就結束了），每一步都將ht[0]上某一個bucket（即一個dictEntry連結串列）上的每一個dictEntry移動到ht[1]上，它在ht[1]上的新位置根據ht[1]的sizemask進行重新計算。rehashidx記錄了當前尚未遷移（有待遷移）的ht[0]的bucket位置。

如果dictRehash被呼叫的時候，rehashidx指向的bucket裡一個dictEntry也沒有，那麼它就沒有可遷移的資料。這時它嘗試在ht[0].table陣列中不斷向後遍歷，直到找到下一個存有資料的bucket位置。如果一直找不到，則最多走n*10步，本次重雜湊暫告結束。

最後，如果ht[0]上的資料都遷移到ht[1]上了（即d->ht[0].used == 0），那麼整個重雜湊結束，ht[0]變成ht[1]的內容，而ht[1]重置為空。

根據以上對於重雜湊過程的分析，我們容易看出，本文前面的dict結構圖中所展示的正是rehashidx=2時的情況，前面兩個bucket（ht[0].table[0]和ht[0].table[1]）都已經遷移到ht[1]上去了。

#### dict的插入（dictAdd和dictReplace）

dictAdd插入新的一對key和value，如果key已經存在，則插入失敗。

dictReplace也是插入一對key和value，不過在key存在的時候，它會更新value。

int dictAdd(dict *d, void *key, void *val)
    {
        dictEntry *entry = dictAddRaw(d,key);
    
        if (!entry) return DICT_ERR;
        dictSetVal(d, entry, val);
        return DICT_OK;
    }
    
    dictEntry *dictAddRaw(dict *d, void *key)
    {
        int index;
        dictEntry *entry;
        dictht *ht;
    
        if (dictIsRehashing(d)) _dictRehashStep(d);
    
        /* Get the index of the new element, or -1 if
         * the element already exists. */
        if ((index = _dictKeyIndex(d, key)) == -1)
            return NULL;
    
        /* Allocate the memory and store the new entry.
         * Insert the element in top, with the assumption that in a database
         * system it is more likely that recently added entries are accessed
         * more frequently. */
        ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
        entry = zmalloc(sizeof(*entry));
        entry->next = ht->table[index];
        ht->table[index] = entry;
        ht->used++;
    
        /* Set the hash entry fields. */
        dictSetKey(d, entry, key);
        return entry;
    }
    
    static int _dictKeyIndex(dict *d, const void *key)
    {
        unsigned int h, idx, table;
        dictEntry *he;
    
        /* Expand the hash table if needed */
        if (_dictExpandIfNeeded(d) == DICT_ERR)
            return -1;
        /* Compute the key hash value */
        h = dictHashKey(d, key);
        for (table = 0; table <= 1; table++) {
            idx = h & d->ht[table].sizemask;
            /* Search if this slot does not already contain the given key */
            he = d->ht[table].table[idx];
            while(he) {
                if (key==he->key || dictCompareKeys(d, key, he->key))
                    return -1;
                he = he->next;
            }
            if (!dictIsRehashing(d)) break;
        }
        return idx;
    }

以上是dictAdd的關鍵實現程式碼。我們主要需要注意以下幾點：

*   它也會觸發推進一步重雜湊（_dictRehashStep）。
*   如果正在重雜湊中，它會把資料插入到ht[1]；否則插入到ht[0]。
*   在對應的bucket中插入資料的時候，總是插入到dictEntry的頭部。因為新資料接下來被訪問的機率可能比較高，這樣再次查詢它時就比較次數較少。
*   _dictKeyIndex在dict中尋找插入位置。如果不在重雜湊過程中，它只查詢ht[0]；否則查詢ht[0]和ht[1]。
*   _dictKeyIndex可能觸發dict記憶體擴充套件（_dictExpandIfNeeded，它將雜湊表長度擴充套件為原來兩倍，具體請參考dict.c中原始碼）。

dictReplace在dictAdd基礎上實現，如下：

int dictReplace(dict *d, void *key, void *val)
    {
        dictEntry *entry, auxentry;
    
        /* Try to add the element. If the key
         * does not exists dictAdd will suceed. */
        if (dictAdd(d, key, val) == DICT_OK)
            return 1;
        /* It already exists, get the entry */
        entry = dictFind(d, key);
        /* Set the new value and free the old one. Note that it is important
         * to do that in this order, as the value may just be exactly the same
         * as the previous one. In this context, think to reference counting,
         * you want to increment (set), and then decrement (free), and not the
         * reverse. */
        auxentry = *entry;
        dictSetVal(d, entry, val);
        dictFreeVal(d, &auxentry);
        return 0;
    }

在key已經存在的情況下，dictReplace會同時呼叫dictAdd和dictFind，這其實相當於兩次查詢過程。這裡Redis的程式碼不夠最佳化。

#### dict的刪除（dictDelete）

dictDelete的原始碼這裡忽略，具體請參考dict.c。需要稍加註意的是：

*   dictDelete也會觸發推進一步重雜湊（_dictRehashStep）
*   如果當前不在重雜湊過程中，它只在ht[0]中查詢要刪除的key；否則ht[0]和ht[1]它都要查詢。
*   刪除成功後會呼叫key和value的解構函式（keyDestructor和valDestructor）。

* * *

dict的實現相對來說比較簡單，本文就介紹到這。在下一篇中我們將會介紹Redis中動態字串的實現——sds，敬請期待。

**原創文章，轉載請註明出處，幷包含下面的二維碼！否則拒絕轉載！**
**本文連結：**[http://zhangtielei.com/posts/blog-redis-dict.html](http://zhangtielei.com/posts/blog-redis-dict.html)

![我的微信公眾號: tielei-blog (張鐵蕾)](http://zhangtielei.com/assets/my_weixin_sign_sf_840.jpg)

探索Redis設計與實現2：Redis內部資料結構詳解——dict

相關文章