redis之dict

类型介绍

dict部分是redis的内存核心，其实质就是一个哈希表结构，这点和memcached有着异曲同工之妙，只不过memcached在查找和分配内存上做了分离，将slabs和assoc建立了联系，而redis更加简洁，直接就包含了两者，这是因为redis没有固定内存的格式大小，不需要提前去预分配那些内存空间，另外应该可以提到一点就是redis不使用memcached的内存分配方式的另一个原因应该就是支持类型的问题，后面可以看到的，redis支持的数据类型要比memcached丰富的多，之所以两者都采用哈希表结果作为存储核心，这是由缓存的特性和要求决定的，缓存就是用来提高访问速度的，哈希表能够提供接近于O(1)的时间复杂度的增删改查操作；
上面提到了数据操作，dict部分作为底层数据结构，同样提供了增加、删除、修改等操作以及迭代器部分，同时和memcached一样，dict部分同样存在两张哈希表，这两个表是用来调整内存大小的，当现在的哈希表大小不满足需求时就要动态调整大小，注意，这里面是动态调整，也就是说redis的rehash过程不是一次性完成，这点和memcached不一样，这是因为memcached的架构是多线程的，可以通过加锁的方式不影响数据访问，而redis是单线程的，如果不是增量式的调整大小，会导致程序阻塞。

代码分析

自定义类型

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;

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];  //两个，类似于memcached中primary_hashtable和old_hashtable的功能
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;  //字典

typedef struct dictIterator {
    dict *d;
    long index;
    int table, safe;
    dictEntry *entry, *nextEntry;
    /* unsafe iterator fingerprint for misuse detection. */
    long long fingerprint;
} dictIterator;

定义变量

dict_can_resize，是否能够调整大小；
dict_force_resize_ratio，强制调整大小的比率；

代码分解

_dictReset，重置字典结构内部变量；

static void _dictReset(dictht *ht)
{
    ht->table = NULL;
    ht->size = 0;
    ht->sizemask = 0;
    ht->used = 0;
}

_dictInit，初始化字典；

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;
}

dictCreate，创建一个字典结构；

dict *dictCreate(dictType *type,
        void *privDataPtr)
{
    dict *d = zmalloc(sizeof(*d));

    _dictInit(d,type,privDataPtr);
    return d;
}

dictResize，调整字典大小；

int dictResize(dict *d)
{
    int minimal;

    //只有当字典允许哈希，且当前不在rehash的时候才能调整大小
    if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;
    minimal = d->ht[0].used;   //已使用空间
    if (minimal < DICT_HT_INITIAL_SIZE)  
        minimal = DICT_HT_INITIAL_SIZE;  //至少是要达到hash表的最小值
    return dictExpand(d, minimal);
}

dictExpand，扩展字典；

int dictExpand(dict *d, unsigned long size)
{
    dictht n; /* the new hash table */
    //找到下一个适合当前大小的hash表大小，为2的幂数：
    unsigned long realsize = _dictNextPower(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. */
    //如果大小与现在大小一样，失去了重新hash的意义
    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;  //哈希掩码
    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. */
    //这里说的是，这个地方如果是第一次初始化的话，就不是一个rehash的过程，我们只需要将字典第一个哈希表设置为刚刚创建的hash表即可
    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;
    return DICT_OK;
}

dictRehash，rehash过程，每次移动n位；

int dictRehash(dict *d, int n) {
    //待访问的空槽位的数目
    int empty_visits = n*10; /* Max number of empty buckets to visit. */
    if (!dictIsRehashing(d)) return 0;  //rehash中直接返回

    //循环次数完毕，或者已使用的以为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;  //到达设定的最大空槽数则退出，返回1表示rehash过程未完成
        }
        de = d->ht[0].table[d->rehashidx];  //此时找到的不为空的槽
        /* Move all the keys in this bucket from the old to the new hash HT */
        //下面将所有槽中数据移动到新的hash表中
        while(de) {  //这里需要注意的是，并不是说把某个槽里面的一个链表整体移到一个新hash表的槽里面就可以了，而是需要将该槽里面的每个元素遍历，然后根据key值重新计算该元素在新的hash表中应该属于的槽
            unsigned int h;

            nextde = de->next;
            /* Get the index in the new hash table */
            h = dictHashKey(d, de->key) & d->ht[1].sizemask;  //计算在hash表中新的位置
            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) {  //如果已完成所有槽的rehash
        zfree(d->ht[0].table);   //释放原来hash表的数据槽
        d->ht[0] = d->ht[1];  //将新的再次转移到0号位上
        _dictReset(&d->ht[1]);  //重置1号位的hash表
        d->rehashidx = -1;  //新的，将rehash重新置位
        return 0;
    }

    /* More to rehash... */
    return 1;  //未完成即退出，需要进行继续rehash
}

dictRehashMilliseconds, rehash过程，设定单次rehash时间；

int dictRehashMilliseconds(dict *d, int ms) {
    long long start = timeInMilliseconds();
    int rehashes = 0;

    while(dictRehash(d,100)) {
        rehashes += 100;
        if (timeInMilliseconds()-start > ms) break;
    }
    return rehashes;
}

dictAdd，添加元素；

int dictAdd(dict *d, void *key, void *val)
{
    dictEntry *entry = dictAddRaw(d,key);  //为当前key找到一个内存区，用于设置value

    if (!entry) return DICT_ERR;
    dictSetVal(d, entry, val);  //设置value
    return DICT_OK;
}

dictAddRaw

dictEntry *dictAddRaw(dict *d, void *key)
{
    int index;
    dictEntry *entry;
    dictht *ht;

    //正在rehash中，进行一步rehash
    if (dictIsRehashing(d)) _dictRehashStep(d);

    /* Get the index of the new element, or -1 if
     * the element already exists. */
    //找到可以存放key的空槽，返回索引，如果已存在，返回-1
    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. */
    //下面是说如果找到了index，则申请内存，然后将该entry添加到hash表的头部
    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;
}

dictReplace，替换

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. */
    //首先添加该k/v，如果键值不存在，则会添加成功
    if (dictAdd(d, key, val) == DICT_OK)
        return 1;
    /* It already exists, get the entry */
    //如果存在，则找到该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;
    //重新设置该entry的value
    dictSetVal(d, entry, val);
    //释放该value
    dictFreeVal(d, &auxentry);
    return 0;
}

dictReplaceRaw，这个函数实际上是一个简化版的dictAddRaw，这里肯定会返回一个给定key的存储空间；

dictEntry *dictReplaceRaw(dict *d, void *key) {
    dictEntry *entry = dictFind(d,key);  //首先查找是否存在该key的entry

    return entry ? entry : dictAddRaw(d,key);  //有直接发挥，没有新增该key
}

dictGenericDelete，通用删除方式，先查找，后删除

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

    if (d->ht[0].size == 0) return DICT_ERR; /* d->ht[0].table is NULL */
    if (dictIsRehashing(d)) _dictRehashStep(d);
    h = dictHashKey(d, key);   //计算该key的hash值

    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 DICT_OK;
            }
            prevHe = he;
            he = he->next;
        }
        //如果没有在rehash过程中，则跳出，不在1号table中查找
        if (!dictIsRehashing(d)) break;
    }
    return DICT_ERR; /* not found */
}

dictDelete，删除某个key对应的entry；

int dictDelete(dict *ht, const void *key) {
    return dictGenericDelete(ht,key,0);  //释放空间
}

dictDeleteNoFree，删除某个key对应的entry，不释放空间；

int dictDeleteNoFree(dict *ht, const void *key) {
    return dictGenericDelete(ht,key,1);
}

_dictClear，释放整个哈希表；

int _dictClear(dict *d, dictht *ht, void(callback)(void *)) {
    unsigned long i;

    /* Free all the elements */
    for (i = 0; i < ht->size && ht->used > 0; i++) {
        dictEntry *he, *nextHe;

        if (callback && (i & 65535) == 0) callback(d->privdata);

        if ((he = ht->table[i]) == NULL) continue;
        while(he) {
            nextHe = he->next;
            dictFreeKey(d, he);
            dictFreeVal(d, he);
            zfree(he);
            ht->used--;
            he = nextHe;
        }
    }
    /* Free the table and the allocated cache structure */
    zfree(ht->table);
    /* Re-initialize the table */
    _dictReset(ht);
    return DICT_OK; /* never fails */
}

dictRelease，释放字典；

void dictRelease(dict *d)
{
    _dictClear(d,&d->ht[0],NULL);
    _dictClear(d,&d->ht[1],NULL);
    zfree(d);
}

dictFind，查找某个key对应的entry;

dictEntry *dictFind(dict *d, const void *key)
{
    dictEntry *he;
    unsigned int h, idx, table;

    //dict都为空
    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;
        }
        //没有在rehash过程中，直接退出，返回NULL
        if (!dictIsRehashing(d)) return NULL;
    }
    return NULL;
}

dictFetchValue，获取该key对应的value；

void *dictFetchValue(dict *d, const void *key) {
    dictEntry *he;

    he = dictFind(d,key);  //首先查找该key对应的entry
    return he ? dictGetVal(he) : NULL;  //找到的话才去获取value，没找到返回NULL
}

dictGetIterator，获取一个dict字典的迭代器；

dictIterator *dictGetIterator(dict *d)
{
    dictIterator *iter = zmalloc(sizeof(*iter));

    iter->d = d;  
    iter->table = 0;
    iter->index = -1;
    iter->safe = 0;
    iter->entry = NULL;
    iter->nextEntry = NULL;
    return iter;
}

dictGetSafeIterator，获取一个安全迭代器；

dictIterator *dictGetSafeIterator(dict *d) {
    dictIterator *i = dictGetIterator(d);

    i->safe = 1;  //safe标记位置1
    return i;
}

dictNext，获取下一个entry，这个函数有点意思，意思在于这个迭代器和之前链表的迭代器有所不同，这里不仅需要判断是在哪个bucket里面，也需要判断是在哪个table中，最后还要考虑下是在哪个链表中的哪个entry；

dictEntry *dictNext(dictIterator *iter)
{
    while (1) {
        if (iter->entry == NULL) {  //如果当前指向的entry为空，可能是迭代器的开始，也可能是一个链表迭代到头了，也有可能是当前正在rehash中，数据已经转移了
            dictht *ht = &iter->d->ht[iter->table];
            if (iter->index == -1 && iter->table == 0) {
            //当前索引为负，起始点
                if (iter->safe)
                    iter->d->iterators++;  //迭代器的个数
                else
                    iter->fingerprint = dictFingerprint(iter->d);
            }
            iter->index++;  //索引加1
            if (iter->index >= (long) ht->size) {
            //超过size，则重新开始
                if (dictIsRehashing(iter->d) && iter->table == 0) {  //如果正在rehash
                    iter->table++;  //跳到1号哈希表
                    iter->index = 0;  //从头开始
                    ht = &iter->d->ht[1];  //获取当前哈希表
                } else {
                    break;  //如果是超出了哈希表的大小，且没有rehash，则会判断出错，返回NULL
                }
            }
            iter->entry = ht->table[iter->index];  //得到当前entry
        } else {
            iter->entry = iter->nextEntry;  //已存在，将该entry的后置节点赋值给
        }
        if (iter->entry) {
            /* We need to save the 'next' here, the iterator user
             * may delete the entry we are returning. */
            iter->nextEntry = iter->entry->next;
            return iter->entry;
        }
    }
    return NULL;
}

dictReleaseIterator，释放迭代器；

void dictReleaseIterator(dictIterator *iter)
{
    //如果该迭代器尚未添加到一个字典中，则跳过处理，直接释放
    if (!(iter->index == -1 && iter->table == 0)) {
        if (iter->safe)
            iter->d->iterators--;
        else
            assert(iter->fingerprint == dictFingerprint(iter->d));
    }
    zfree(iter);
}