redis源码系列-数据结构(adlist/ziplist/dict)

该系列基于redis-2.8.18，主要记录自己的理解或者想法。redis以自己支持存储的数据结构丰富吸引了大批人，把memcached比了下去。本文就从简单基本的数据结构入手。

双向链表-adlist

typedef struct listNode {
    struct listNode *prev;
    struct listNode *next;
    void *value;
} listNode;

typedef struct listIter {
    listNode *next;
    int direction;
} listIter;

typedef struct list {
    listNode *head;
    listNode *tail;
    void *(*dup)(void *ptr);//使用函数指针便于扩展，不同的业务指定自己的实现
    void (*free)(void *ptr);
    int (*match)(void *ptr, void *key);
    unsigned long len;
} list;

压缩链表-ziplist

ziplist是双向链表的一种实现，采用一些编码技巧高效的使用一块连续的内存，每个节点可以保存字符串或者整数。ziplist常用做其他数据结构的一种底层实现方式。

内存结构如下图：

zlbytes：ziplist占用的字节数（不包括zlbytes自己，最小是7），unsigned int类型。可以算出一个ziplist最多2**32-1byte，大概4G。

zltail：从zltail到最后一个entry的距离(byte)-zlbytes结尾到last entry的开头，zltail最少是6，len(zltail)+len(zllen)。这样可以O(1)找到尾部，不用遍历整个list。

zllen：ziplist的节点数，大小是2byte，最多代表2**16-2=65534个（为啥是减2？因为减1是2byte表示的最大数，被用于表示超过zllen范围了，zllen无效了），超过的就得遍历list获得有效节点数。

zlend：各位全是1（255），表示ziplist的结尾。zltail可以找到last entry，那不用zlend行不行？那在遍历链表时需要记录遍历的个数，等于zltail时才能停止。

entry：一个具体的节点，其内部结构如下。

pre-entry-len：上一个节点的长度(byte)，便于回退。

encoding：表示该节点存储的数据类型，string或整型。

entry-len：该节点的value大小，entry-len占用的bit数与存储类型有关，如下。

字符串类型：
encoding=00，strlen<=63，entry-len占6bit
encoding=01, strlen <= 16383，entry-len占14bit
encoding=10, strlen>=16384, entry-len占38bit

整型类型：

encoding+entry-len共占1byte，encoding=11，后面6bit用于表示整数类型（int16_t/int32_t/int64_t等）。

11 000000代表int16_t，
11 010000代表int32_t，
11 100000代表int64_t，
11 110000代表int24
11 111110代表int8
11 11xxxx：0001 <= xxxx <= 1101(从上面看0000/11110不能用)，xxxx就是存储的整数值，虽然实际存储的是1到13，解释成0到12。

补：

ziplist是一块连续的内存，所以每次新增都重新分配内存，删除会压缩内存(后面的往前移，void * memmove ( void * destination, const void * source, size_t num ))

值和bit的变换-需要用到void * memcpy ( void * destination, const void * source, size_t num )，整型还会用到强制类型转换和移位。

散列表-dict

散列表，使用拉链法解决hash冲突。比较有意思的是使用渐进式重hash的方法来扩大散列表大小。

何时resize？新增元素时，检查ht[0]中used/size > ratio（默认为5），如果true，会新生成ht[1]，大小大于等于2*used，且为2的指数次方。used是保存的元素个数，size是散列表的桶个数。开始渐进式rehash，将ht[0]中的元素逐渐rehash到ht[1]中。

何为渐进式？每当新增、删除、查找元素时，如果散列表处于rehash(rehashidx!=-1)时，就rehash一个桶(有相同hash值的链表)到ht[1]，直到rehash结束。

过程中的注意点？rehash中新增元素都放到ht[1]中，查找要遍历2个ht，以ht[1]中的为准。如果有safe iterator就要暂停rehash，以保证基于iterator的操作安全。

优缺点？resize过程中不中断散列表的使用，缺点是新旧列表并存，resize过程中长期占用多余的空间。

typedef struct dictEntry {
    void *key;
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry *next;
} dictEntry;
/* 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];//ht[0]为默认使用，resize时将ht[0]中的元素逐一rehash到ht[1]，最后ht[1]复制给后台[0]
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    int iterators; /* number of iterators currently running，记录safe iterator个数，如果非0，就暂停rehash*/
} 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;//0非安全，1安全
    dictEntry *entry, *nextEntry;
    /* unsafe iterator fingerprint for misuse detection. */
    long long fingerprint;//是散列表各属性的异或
} dictIterator;
//dictType,散列表实现操作，如key比较/hash函数
typedef struct dictType {
    unsigned int (*hashFunction)(const void *key);//hash function
    void *(*keyDup)(void *privdata, const void *key);//duplicate key
    void *(*valDup)(void *privdata, const void *obj);//duplicate value
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);//key compare
    void (*keyDestructor)(void *privdata, void *key);
    void (*valDestructor)(void *privdata, void *obj);
} dictType;

函数指针挺好的，与面向对象编程中的继承有异曲同工的效果，实现了多态。下图是散列表结构：