最近，我想通过redis的源码来学习redis。虽然平时工作中用得不多，不过对redis还是比较感兴趣的，毕竟它的性能是不错的。redis是一个 开源的项目，我们可以通过源代码去了解redis。我后面会通过自己的学习，写一些关于redis源码的帖子。帖子的主要内容是分析代码设计，而并不会对 源码进行详细解说。如果有不对的地方，请指正。源码是reids 3.0.3版本。


dict 字典


一、数据结构

//字典条目
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);    //计算key的哈希值
    void *(*keyDup)(void *privdata, const void *key);    //复制key的函数
    void *(*valDup)(void *privdata, const void *obj);    //复制value的函数
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);//比较key相等的函数
    void (*keyDestructor)(void *privdata, void *key);//销毁key的函数
    void (*valDestructor)(void *privdata, void *obj);//销毁value的函数
} 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];    //两个哈希表，在rehash时会使用两个哈希表，否则只会使用一个表
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    int iterators; /* number of iterators currently running */
} dict;
/* If safe is set to 1 this is a safe iterator, that means, you can call
 * dictAdd, dictFind, and other functions against the dictionary even while
 * iterating. Otherwise it is a non safe iterator, and only dictNext()
 * should be called while iterating. */
typedef struct dictIterator {
    dict *d;
    long index;
    int table, safe;
    dictEntry *entry, *nextEntry;
    /* unsafe iterator fingerprint for misuse detection. */
    long long fingerprint;
} dictIterator;



二、宏实现的简单函数

举三个例子：

#define dictFreeVal(d, entry) \
    if ((d)->type->valDestructor) \
        (d)->type->valDestructor((d)->privdata, (entry)->v.val)
#define dictSetVal(d, entry, _val_) do { \
    if ((d)->type->valDup) \
        entry->v.val = (d)->type->valDup((d)->privdata, _val_); \
    else \
        entry->v.val = (_val_); \
} while(0)
#define dictSetSignedIntegerVal(entry, _val_) \
    do { entry->v.s64 = _val_; } while(0)

dictFreeVal，在释放字典条目的value时使用。实现中没使用 do{}while(0)，我没有想明白是为何不使用，但我觉得应该加的，不然使用不当时会出问题，具体可见我的另一个贴子：http://chhquan.blog.51cto.com/1346841/1358254

dictSetSignedIntegerVal 中加上do{}while(0)，应该是为了阻止以表达形式使用宏。


三、部分代码解析

由于dict行为特点比较多，本贴子打算详解部分代码。


1. dict_can_resize

/* Using dictEnableResize() / dictDisableResize() we make possible to
 * enable/disable resizing of the hash table as needed. This is very important
 * for Redis, as we use copy-on-write and don't want to move too much memory
 * around when there is a child performing saving operations.
 *
 * Note that even when dict_can_resize is set to 0, not all resizes are
 * prevented: a hash table is still allowed to grow if the ratio between
 * the number of elements and the buckets > dict_force_resize_ratio. */
static int dict_can_resize = 1;
static unsigned int dict_force_resize_ratio = 5;

dict_can_resize，可控制dict是否可以进行rehash，1 时允许rehash，0 - 通常情况不允许rehash，但如果满足 条目数/桶 > dict_force_resize_ratio时，仍可进行rehash。通过 dictEnableResize() 或 dictDisableResize() 可以设置 dict_can_resize。这样的设置的目的在于：当redis需要对dict进行保存操作时（写文件），是要把dict的当前快照作保存，要保持dict不变，但这样会使字典的不能接收写入操作或是进行rehash，为了确保dict能正常处理请求，redis采用copy-on-write的策略，即当dict有修改操作时，需要把dict进行复制，以同时支持保存操作和修改操作。由于rehash也是对dict进行修改，也可能会使正在保存的dict进行复制，所以使用 dict_force_resize_ratio 可阻止rehash，从而一定程度上避免复制。但如果保存 条目数/桶 > dict_force_resize_ratio 时，redis认为这时dict的条目数相对于桶来说已经太多了，有些桶上所挂的元素个数可能比较多，对dict的效率产生严重的影响。所以此时宁可复制dict也要允许rehash以恢复dict的性能。当然具体 dict_force_resize_ratio 是多少，应该由实验得出吧。又或者如何度量复制与保持dict高效的转折点也是要进行实验的，不一定是 条目数/桶，具体也就由实验得出吧。由于没有实验，我也不能多说了。

2. hash计算

计算hash值的函数，具体算法我也不并熟悉，跳过。

3. 重置哈希表

//重置哈希表
/* Reset a hash table already initialized with ht_init().
 * NOTE: This function should only be called by ht_destroy(). */
static void _dictReset(dictht *ht)
{
    //下面直接覆盖table的值，调用方需确保table要么不指向一块动态内存，
    //要么动态内存已被释放，要么还有别的指针保留table所指向的动态内存空间
    ht->table = NULL;    
    ht->size = 0;
    ht->sizemask = 0;
    ht->used = 0;
}


4. 创建dict

//创建dict
/* Create a new hash table */
dict *dictCreate(dictType *type,
        void *privDataPtr)
{
    dict *d = zmalloc(sizeof(*d));
    _dictInit(d,type,privDataPtr);
    return d;
}


5. 初始化dict

//初始化dict
/* Initialize the hash table */
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;    // -1为不在rehash状态，>= 0 为rehash中
    d->iterators = 0;
    return DICT_OK;
}


6. 调整大小

//resize，根据dict中已存储的条目数进行resize，可扩展哈希表空间也可缩小。
/* Resize the table to the minimal size that contains all the elements,
 * but with the invariant of a USED/BUCKETS ratio near to <= 1 */
int dictResize(dict *d)
{
    int minimal;
    if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
    minimal = d->ht[0].used;    //按已存储的条目数进行resize
    if (minimal < DICT_HT_INITIAL_SIZE)    //最小resize大小为 DICT_HT_INITIAL_SIZE
        minimal = DICT_HT_INITIAL_SIZE;
    return dictExpand(d, minimal);
}
/* Expand or create the hash table */
int dictExpand(dict *d, unsigned long size)
{
    dictht n; /* the new hash table */
    unsigned long realsize = _dictNextPower(size); //取大于size的最小的2的幂作为实际size
    /* the size is invalid if it is smaller than the number of
     * elements already inside the hash table */
    if (dictIsRehashing(d) || d->ht[0].used > size)
        return DICT_ERR;
    /* Rehashing to the same table size is not useful. */
    if (realsize == d->ht[0].size) return DICT_ERR;
    /* Allocate the new hash table and initialize all pointers to NULL */
    n.size = realsize;
    n.sizemask = realsize-1; //size-1，bit为1的都在低位，用于对哈希值取size的模作为哈希表的桶号
    n.table = zcalloc(realsize*sizeof(dictEntry*));
    n.used = 0;
    /* Is this the first initialization? If so it's not really a rehashing
     * we just set the first hash table so that it can accept keys. */
    if (d->ht[0].table == NULL) {
        d->ht[0] = n;
        return DICT_OK;
    }
    /* Prepare a second hash table for incremental rehashing */
    d->ht[1] = n;
    d->rehashidx = 0;//>=0，正在rehash中
    return DICT_OK;
}


7. rehash

//rehash函数，逐步对dict进行rehash
//redis并没有一次性完成对dict的rehash，而是把整个rehash过程分成许多小的rehash操作去完成，
//每一次rehash都会处理至多一定数量的桶，由参数n指定。由于部分桶是空的，为防止rehash一直都访问
//到空的桶使rehash过程耗时过多，函数里面设定最多访问 n*10 个桶。
//redis为保持性能的稳定，会把一些有机会耗时较比多的操作，分成放多小的操作，rehash便是其中一个例子。
/* Performs N steps of incremental rehashing. Returns 1 if there are still
 * keys to move from the old to the new hash table, otherwise 0 is returned.
 *
 * Note that a rehashing step consists in moving a bucket (that may have more
 * than one key as we use chaining) from the old to the new hash table, however
 * since part of the hash table may be composed of empty spaces, it is not
 * guaranteed that this function will rehash even a single bucket, since it
 * will visit at max N*10 empty buckets in total, otherwise the amount of
 * work it does would be unbound and the function may block for a long time. */
int dictRehash(dict *d, int n) {
    int empty_visits = n*10; /* Max number of empty buckets to visit. */
    if (!dictIsRehashing(d)) return 0;
    //访问ht[0]中的桶，如果桶非空，把桶中的元素放进ht[1]里。
    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 */
    //从rehashidx开始，rehashidx便是用来记录rehash过程状态的变量
        assert(d->ht[0].size > (unsigned long)d->rehashidx);
    //找出一个非空桶，总的访问次数受到 empty_visits 的限制
        while(d->ht[0].table[d->rehashidx] == NULL) {
            d->rehashidx++;
            if (--empty_visits == 0) return 1;    //返回1表示rehash还没完成，需要进行进行
        }
        de = d->ht[0].table[d->rehashidx];
    //移动桶中所有条目到ht[1]中
        /* 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++;    //已经处理了rehashidx 号桶，下一个桶
    }
    //如果ht[0]已经没有条目了，可以把ht[1]切换到ht[0]，并重置ht[1]。
    /* Check if we already rehashed the whole table... */
    if (d->ht[0].used == 0) {
        zfree(d->ht[0].table);    //释放ht[0]的桶空间
        d->ht[0] = d->ht[1];
        _dictReset(&d->ht[1]);
        d->rehashidx = -1;
        return 0;
    }
    /* More to rehash... */
    return 1;
}

由rehash过程可以看出，在rehash过程中，ht[0]和ht[1]同时具有条目，即字典中的所有条目分布在ht[0]和ht[1]中，
这时麻烦也就出来了。主要有以下问题：（现在暂不解答是如何解决的）
1.如何查找key。
2.如何插入新的key。
3.如何删除一个key。
4.如何遍历dict所有条目，如何确保遍历顺序。
5.如何确保rehash过程不断插入、删除条目，而rehash没有出错。
6.如何确保迭代器有效，且正确。