Redis 源碼解析 4：字典 dict

Redis 中，字典是基礎結構。Redis 數據庫數據、過期時間、哈希類型都是把字典作為底層結構。

字典的結構

哈希表

哈希表的實現代碼在：dict.h/dictht ，Redis 的字典用哈希表的方式實現。

typedef struct dictht {
    // 哈希表數組，俗稱的哈希桶(bucket)
    dictEntry **table;
    // 哈希表的長度
    unsigned long size;
    // 哈希表的長度掩碼，用來計算索引值，保證不越界。總是 size - 1
    // h = dictHashKey(ht, he->key) & n.sizemask;
    unsigned long sizemask;
    // 哈希表已經使用的節點數
    unsigned long used;
} dictht;

• table 是一個哈希表數組，每個節點的實現在 dict.h/dictEntry，每個 dictEntry 保存一個鍵值對。
• size 屬性記錄了向系統申請的哈希表的長度，不一定都用完，有預留空間的。
• sizemask 屬性主要是用來計算 索引值 = 哈希值 & sizemask，這個索引值決定了鍵值對放在 table 的哪個位置。它的值總是 size - 1，其實我有點不明白為啥計算的時候不直接用 size - 1，知道的大佬請明示。
• used 屬性用來記錄已經使用的節點數，size - use 就是未使用的節點啦。

下圖展示了一個大小為 4 的空哈希表結構，沒有任何鍵值對

哈希節點

哈希表 dictht 的 table 的元素由哈希節點 dictEntry 組成，每一個 dictEntry 就是一個鍵值對

typedef struct dictEntry {
    // 鍵
    void *key;
    // 值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    // 下一個哈希節點，用於哈希沖突時拉鏈表用的
    struct dictEntry *next;
} dictEntry;

next 指針是用於當哈希沖突的時候，可以形成鏈表用的。后續會將

字典

Redis 的字典實現在： dict.h/dict 。

typedef struct dict {
    // 哈希算法
    dictType *type;
    // 私有數據，用於不同類型的哈希算法的參數
    void *privdata;
    // 兩個哈希表，用兩個的原因是 rehash 擴容縮容用的
    dictht ht[2];
    // rehash 進行到的索引值，當沒有在 rehash 的時候，為 -1
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    // 正在跑的迭代器
    unsigned long iterators; /* number of iterators currently running */
} dict;

// dictType 實際上就是哈希算法，不知道為啥名字叫 dictType
typedef struct dictType {
    // hash方法，根據 key 計算哈希值
    uint64_t (*hashFunction)(const void *key);
    // 復制 key
    void *(*keyDup)(void *privdata, const void *key);
    // 復制 value
    void *(*valDup)(void *privdata, const void *obj);
    // key 比較
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
    // 銷毀 key
    void (*keyDestructor)(void *privdata, void *key);
    // 銷毀 value
    void (*valDestructor)(void *privdata, void *obj);
} dictType;

dictType 屬性表示字典類型，實際上這個字典類型就是一組操作鍵值對算法，里面規定了很多函數。
privdata 則是為不同類型的 dictType 提供的可選參數。
如果有需要，在創建字典的時候，可以傳入dictType 和 privdata。

dict.c

// 創建字典，這里有 type 和 privdata 可以傳
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;
}

下圖是比較完整的普通狀態下的 dict 的結構(沒有進行 rehash，也沒有迭代器的狀態)：

哈希算法

當字典中需要添加新的鍵值對時，需要先對鍵進行哈希，算出哈希值，然后在根據字典的長度，算出索引值。

// 使用哈希字典里面的哈希算法，算出哈希值
hash = dict->type->hashFunction(key)
// 使用 sizemask 和 哈希值算出索引值
idx = hash & d->ht[table].sizemask;
// 通過索引值，定位哈希節點
he = d->ht[table].table[idx];

哈希沖突

哈希沖突指的是多個不同的 key，算出的索引值一樣。

Redis 解決哈希沖突的方法是：拉鏈法。就是每個哈希節點后面有個 next 指針，當發現計算出的索引值對應的位置有其他節點，那么直接加在前面節點后即可，這樣就形成了一個鏈表。

下圖展示了 {k1, v1} 和 {k2, v2} 哈希沖突的結構。
假設 k1 和 k2 算出的索引值都是 3，當 k2 發現 table[3] 已經有 dictEntry{k1,v1}，那就 dictEntry{k1,v1}.next = dictEntry{k2,v2}。

rehash

隨着操作的不斷進行，哈希表的長度會不斷增減。哈希表的長度太長會造成空間浪費，太短哈希沖突明顯導致性能下降，哈希表需要通過擴容或縮容，讓哈希表的長度保持在一個合理的范圍內。
Redis 通過 ht[0] 和 ht[1] 來完成 rehash 的操作，步驟如下：

1. 為 ht[1] 分配空間，分配的空間長度有兩種情況：
   • 擴容：第一個大於等於 ht[0].used * 2 的 \(2^n\) 的數，例如 ht[0].used = 3，那么分配的是距離 6 最近的 \(2^3=8\)
   • 縮容：第一個大於等於 ht[0].used / 2 的 \(2^n\) 的數，例如 ht[0].used = 6，那么分配的是距離 3 最近的 \(2^2=4\)
2. 將 h[0] 上的鍵值對都遷移到 h[1]，遷移的時候都是重新計算索引值的。由於 h[1] 的長度較長，之前在 h[0] 拉鏈的元素大概率會被分到不同的位置。
3. ht[0] 所有的鍵值對遷移完之后，h[0] 釋放，然后 h[0] = h[1]，並把 h[1] 清空，為下次 rehash 准備

漸進式 rehash

上面說的 rehash 中的第二步，遷移的過程不是一次完成的。如果哈希表的長度比較小，一次完成很快。但是如果哈希表很長，例如百萬千萬，那這個遷移的過程就沒有那么快了，會造成命令阻塞！
下面來說說，redis 是如何漸進式地將 h[0] 中的鍵值對遷移到 h[1] 中的：

1. 為 h[1] 開辟空間，字典同時持有 h[0] 和 h[1]
2. 字典中的 rehashidx 維護了 rehash 的進度，設置為 0 的時候，開始 rehash
3. 字典每次增刪改查的時候，除了完成指定操作之外，還會順帶把 rehashidx 上的整條鏈表遷移到 h[1] 中。遷移完之后 rehashidx + 1
4. 隨着字典的不斷讀取、操作，最終 h[0] 上的所有鍵值對都會遷移到 h[1] 中。全部遷移完成之后 rehashidx = -1

這種漸進式 rehash 的方式的好處在於，將龐大的遷移工作，分攤到每次的增刪改查中，避免了一次性操作帶來的性能的巨大損耗。
缺點就是遷移過程中 h[0] 和 h[1] 同時存在的時間比較長，空間利用率較低。

下面一系列的圖，演示了字典是如何漸進式地 rehash ( 圖片來自 《Redis 設計與實現》圖片集 )

字典的常用操作

1. 查找節點

查找的代碼實現在 dict.c:

#define dictHashKey(d, key) (d)->type->hashFunction(key)
// ...
dictEntry *dictFind(dict *d, const void *key) {
    dictEntry *he;
    uint64_t h, idx, table;
    // 空字典直接返回 NULL
    if (dictSize(d) == 0) return NULL;
    // 如果狀態是正在 rehash，則漸進式 rehash 一步
    if (dictIsRehashing(d)) _dictRehashStep(d);
    // 調用字典的哈希算法進行哈希，算出哈希碼
    h = dictHashKey(d, key);
    
    for (table = 0; table <= 1; table++) {
        // 算出在哈希桶中的 index
        idx = h & d->ht[table].sizemask;
        // 找到對應的哈希槽
        he = d->ht[table].table[idx];
        // 哈希槽是個鏈表
        while(he) {
        	// 遍歷鏈表，找到跟 key 相等的節點
            if (key==he->key || dictCompareKeys(d, key, he->key))
                return he;
            he = he->next;
        }
        // 如果沒有在 rehash，就不找 ht[1] 了
        if (!dictIsRehashing(d)) return NULL;
    }
    return NULL;
}

2. 添加節點

int dictAdd(dict *d, void *key, void *val) {
    // 底層添加節點的方法
    dictEntry *entry = dictAddRaw(d, key, NULL);
    if (!entry) return DICT_ERR;
    // 給節點設置值
    dictSetVal(d, entry, val);
    return DICT_OK;
}

// 添加節點的方法
dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing) {
    long index;
    dictEntry *entry;
    dictht *ht;

    // 國際慣例，rehash 一波
    if (dictIsRehashing(d)) _dictRehashStep(d);

    // 查看插入的 key 是否已經存在，已經在則返回 NULL
    if ((index = _dictKeyIndex(d, key, dictHashKey(d,key), existing)) == -1)
        return NULL;

    // 如果正在 rehash，那就放在 ht[1] 就行了
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = zmalloc(sizeof(*entry));
    // 把節點放到對應的哈希槽
    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;

    // 節點的 key 賦值
    dictSetKey(d, entry, key);
    return entry;
}

3. 刪除節點

刪除的代碼實現在 dict.c，整體來說，前半部分跟查找類似，找到對應的節點之后，再進行刪除:

static dictEntry *dictGenericDelete(dict *d, const void *key, int nofree) {
    uint64_t h, idx;
    dictEntry *he, *prevHe;
    int table;

    // 如果是空的，返回
    if (d->ht[0].used == 0 && d->ht[1].used == 0) return NULL;

    // 國際慣例，rehash 一波
    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];
        prevHe = NULL;
        while(he) {
            if (key==he->key || dictCompareKeys(d, key, he->key)) {
                /* Unlink the element from the list */
                if (prevHe)
                    prevHe->next = he->next;
                else
                    d->ht[table].table[idx] = he->next;
                if (!nofree) {
                    // 釋放節點。
                    dictFreeKey(d, he);
                    dictFreeVal(d, he);
                    zfree(he);
                }
                d->ht[table].used--;
                return he;
            }
            prevHe = he;
            he = he->next;
        }
        if (!dictIsRehashing(d)) break;
    }
    return NULL; /* not found */
}

nofree 參數的意思是"是否要釋放找到的節點的內存"，為什么需要這個參數呢？
因為有一些情況，需要在刪除之前先找到節點的值。
例如 skiplist 編碼的 zset 在刪除之前，需要拿到這個節點對應的 score，再去刪除跳表中的節點，這個后面會有文章專門說。

int zsetDel(robj *zobj, sds ele) {
    if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
        // ...
    } else if (zobj->encoding == OBJ_ENCODING_SKIPLIST) {
        // `skiplist` 編碼
        zset *zs = zobj->ptr;
        dictEntry *de;
        double score;

        // 找到要刪除的哈希節點，但是先不釋放內存
        de = dictUnlink(zs->dict,ele);
        if (de != NULL) {
            // 拿到節點的分數，用於刪掉鏈表節點
            /* Get the score in order to delete from the skiplist later. */
            score = *(double*)dictGetVal(de);
           	// 釋放節點內存
            dictFreeUnlinkedEntry(zs->dict,de);
            // 刪鏈表節點
            int retval = zslDelete(zs->zsl,score,ele,NULL);
            // ...
        }
    }
    // ...
}