下面先來看看dict中的dictAdd方法：

/*
 * 三個引數：字典指標、鍵、值
 */
int dictAdd(dict *d, void *key, void *val)
{
    /* 新建節點,entry=null */
    dictEntry *entry = dictAddRaw(d,key,NULL);
    /* 如果entry不為null，返回1 */
    if (!entry) return DICT_ERR;
    /* 給節點賦值 */
    dictSetVal(d, entry, val);
    /* 操作成功，返回0 */
    return DICT_OK;
}
 

主要看看dictAddRaw：

dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
{
    long index;
    dictEntry *entry;
    dictht *ht; /* 指向字典中的hash表 */

    /* 判斷字典此時是否正在rehash */
    if (dictIsRehashing(d)) _dictRehashStep(d);

    /* 如果新元素已經存在，那麼index=-1，否則index就是新元素的下標值 */
    if ((index = _dictKeyIndex(d, key, dictHashKey(d,key), existing)) == -1)
        return NULL;

    /* 給新的entry分配記憶體空間並且儲存新的entry，
     * 在這裡，會將新的元素放在hash表的表頭
     */
    /* 如果字典這是正在rehash，那麼會將entry新增到ht[1]中去；否則新增到ht[0] */
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = zmalloc(sizeof(*entry));
    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;/* 更新hash表中used屬性的值 */

    /* 設定entry的key */
    dictSetKey(d, entry, key);
    return entry;
}
 

判斷字典是否正在rehash是根據dict中的rehashidx屬性來判斷，如果rehashidx=-1，那麼dict沒有在rehash，否則dict在rehash。

#define dictIsRehashing(d) ((d)->rehashidx != -1)

rehash

如果此時rehashidx!=-1，並且迭代器數量=0，也就是此時並沒有對dict進行迭代，那麼就rehash。以下就是dict的rehash方法：

int dictRehash(dict *d, int n) {
    int empty_visits = n*10; /* 空桶的最大值 */
    if (!dictIsRehashing(d)) return 0; /* 沒有在rehash，那麼返回0 */

    /* 遍歷ht[0] */
    while(n-- && d->ht[0].used != 0) {
        /* 倆指標，分別指向當前節點和當前節點的下一節點 */
        dictEntry *de, *nextde;

        /* 判斷ht[0].size>rehashidx，確保不會溢位 */
        assert(d->ht[0].size > (unsigned long)d->rehashidx);

        /* ht[0]已經被遍歷完，返回1 */
        while(d->ht[0].table[d->rehashidx] == NULL) {
            d->rehashidx++;
            if (--empty_visits == 0) return 1;
        }
        
        /* 當前節點 */
        de = d->ht[0].table[d->rehashidx];
        /* 將所有節點從ht[0]移動到ht[1]中 */
        while(de) {
            uint64_t h;

            nextde = de->next;
            /* 獲取該節點在ht[1]中的新的位置 */
            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++;
    }

    /* 如果ht[0]中的元素全部已經放入ht[1]，那麼釋放ht[0]的空間
     * 將ht[0]指向ht[1]，重置ht[1]，保證dict中總是使用ht[0]，ht[1]作為備用
     */
    if (d->ht[0].used == 0) {
        zfree(d->ht[0].table);
        d->ht[0] = d->ht[1];
        _dictReset(&d->ht[1]);
        /* rehash操作結束 */
        d->rehashidx = -1;
        return 0;
    }

    return 1;
}
 

在rehash中也涉及到對key的hash演算法：

/* 使用redis的hashFunction來計算得到key的hash值 */
#define dictHashKey(d, key) (d)->type->hashFunction(key)

最後會重置ht[1]：

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

回到addDictRaw方法主體，rehash之後，通過_dictKeyIndex方法獲取key的下標值：

static long _dictKeyIndex(dict *d, const void *key, uint64_t hash, dictEntry **existing)
{
    unsigned long idx, table;
    dictEntry *he;
    
    /* key已經存在，返回null */
    if (existing) *existing = NULL;

    /* 判斷是否需要擴充套件dict */
    if (_dictExpandIfNeeded(d) == DICT_ERR)
        return -1;

    /* 遍歷dict中的兩個hash表 */
    for (table = 0; table <= 1; table++) {
        idx = hash & d->ht[table].sizemask;
        /* 遍歷table中所有的已存在的key。判斷新增的key是否已經存在 */
        he = d->ht[table].table[idx];
        while(he) {
            /* 已經存在，返回-1 */
            if (key==he->key || dictCompareKeys(d, key, he->key)) {
                if (existing) *existing = he;
                return -1;
            }
            he = he->next;
        }
        if (!dictIsRehashing(d)) break;
    }
    /* 新增的key不存在，返回新增的key的下標值，也就是hash表的sizemask=size-1 */
    return idx;
}

總結：通過閱讀add方法，瞭解了hash演算法和rehash操作。在rehash的時候，需要將ht[0]中的所有K-V移動到ht[1]中去，這個過程並不是一次性完成，而是“漸進的”。為什麼這樣做呢？這是因為如果ht[0]中的K-V很多，一次性的移動會對伺服器的效能有影響。在rehash過程中，如果執行查詢操作，那麼會先去ht[0]中查詢，如果沒有找到，再去ht[1]中查詢。rehash過程中，如果有新增操作，那麼會直接儲存到ht[1]中，確保ht[0]中的K-V數量只減不增。

另，在add過程中，如果兩個不同的key被分配到同一個hash表中的索引上時，會產生hash衝突，解決這個衝突的方法是鏈地址法，與java中hashmap的解決方法相似。