redis源码分析（4）-- 基本数据结构字典dict

一、字典结构

Redis中字典采用hash表结构，如下：

typedef struct dictht {
    dictEntry **table; // hash表数组
    unsigned long size; // hash表大小
    unsigned long sizemask; // 掩码
    unsigned long used; // 已经使用的大小
} dictht;

table是一个数组，每个元素指向一个dictEntry结构。size表示hash表大小，used表示使用的大小。一个size=4的空hash表如下：

dictEntry是一个key-value pair, 定义为：

typedef struct dictEntry {
    void *key; // key
    union { 
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v; // value
    struct dictEntry *next; // 指向下一个key-value
} dictEntry;

next指针用于解决hash冲突，redis总采用直接链址法解决冲突。举例：

Redis中字典定义:

typedef struct dict {
    dictType *type; // type和privdata区别操作不同类型key-value
    void *privdata;
    dictht ht[2];
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    int iterators; /* number of iterators currently running */
} dict;

ht[2]中一般只有ht[0]使用，ht[1]在rehash时使用，ht[1]和rehashindex使用后续介绍。

 二、hash实现

Redis中使用的hash函数为MurmurHash2， 定义为：

unsigned int dictGenHashFunction(const void *key, int len)

通过宏定义：

#define dictHashKey(d, key) (d)->type->hashFunction(key)

获取hashkey的值，之后使用：

idx = hashkey & d->ht[table].sizemask;

得到hash桶的坐标， 如图：

Redis中使用直接链址法解决冲突，如图：

 三、Rehash

在函数_dictExpandIfNeeded中会判断是否需要扩展hash表：

static int _dictExpandIfNeeded(dict *d)
{
    /* Incremental rehashing already in progress. Return. */
    if (dictIsRehashing(d)) return DICT_OK;

    /* If the hash table is empty expand it to the initial size. */
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);

    /* If we reached the 1:1 ratio, and we are allowed to resize the hash
     * table (global setting) or we should avoid it but the ratio between
     * elements/buckets is over the "safe" threshold, we resize doubling
     * the number of buckets. */
    if (d->ht[0].used >= d->ht[0].size &&
        (dict_can_resize ||
         d->ht[0].used/d->ht[0].size > dict_force_resize_ratio))
    {
        return dictExpand(d, d->ht[0].used*2);
    }
    return DICT_OK;
}

可以看出，当利用率used/size到某个比例时，开始执行hash表扩展，进行rehash。流程为：

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) {// 迁移完毕，更新ht[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;
}

把ht[0]上的数据逐步迁移到ht[1].

四、字典主要API