Redis源码剖析之路（1）：数据结构与对象

俗话说，了解一个人的内心从能真正了解这个人，这句话自古通用，看透本质才能真正了然于心，做到万变不离其宗！

这篇博客更新时间应该很长，希望大家耐心关注看完哈，我也会很耐心写完的！

REmote DIctionary Server(Redis) 是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库
Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的 API。
Redis 通常被称为数据结构服务器，因为值（value）可以是字符串(String)、哈希(Hash)、列表(list)、集合(sets)和有序集合(sorted sets)等类型。

数据结构

SDS

一个SDS数组

typedef char *sds;

一个sdshdr结构体用来标识该数组

struct sdshdr {
    int len;
    int free;
    char buf[];	// 默认是Redis\0，末尾为\0，所以可以使用一些C-API
};

SDS和C数组区别

• C语言获取数组长度时间复杂度为O(N)，sds直接从sdshdr中寻找len，时间复杂度为O(1)
• C语言原生API会造成内存泄露或溢出，Redis-API会将内存扩展到要用的大小（这是一种情况）
• C语言对字符进行操作会使得重复调用内存重分配、系统调用，消耗时间；Redis-API会在第一次就会进行空间预分配（SDS的长度小雨1MB其free属性为len一倍，否则直接加1MB）和惰性空间释放（C语言会重复调用系统调用；SDS不直接使用内存收缩缩短多出来的字节，而是使用free属性记录起来，并等待来使用）
• 二进制安全：C语言数组遇到空字符无法读入（\0作为末尾），且使用ascii编码，Redis可以随意使用
• Redis兼容C语言部分函数

这里不得不提一提一个细节

const sds s = "Hello";
struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));

这个表达式或许有些奇怪，我后来查一查，假设s的地址为404000，那么sh的地址就为403ff8，而根据结构体的内容可以知道前面有八个字节（两个int），所以buf区域地址为404000，和s指向的是一个地址！
综上，这里是两个指针指向一个内存地址！将s和sdshdr绑定了！所以才会说sdshdr是s的状态和信息。

我们来看几个函数

获取sds的长度

static inline size_t sdslen(const sds s) {
    struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr)));
    return sh->len;
}

将两个sds拼接到一起

sds sdscat(sds s, const char *t) {
    return sdscatlen(s, t, strlen(t));
}
sds sdscatlen(sds s, const void *t, size_t len) {
    struct sdshdr *sh;
    size_t curlen = sdslen(s);
    // 扩展 sds 空间
    // T = O(N)
    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    
    sh = (void*) (s-(sizeof(struct sdshdr)));
    memcpy(s+curlen, t, len);
    
    sh->len = curlen+len;
    sh->free = sh->free-len;
    s[curlen+len] = '\0';
    return s;
}

链表

当一个列表键包含了数量比较多的元素，又或者列表中包含的元素都是比较长的字符串时，Redis就会使用链表作为列表键的底层实现。

结点

// 使用双向链表实现
typedef struct listNode {
    struct listNode *prev;
    struct listNode *next;
    void *value;
} listNode;

他还使用了一个管理器来管理所有的结点

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;

特点：

• 无环
• 双向：或许前置结点或后置结点时间复杂度为O(1)
• 管理器带表头指针和表尾指针，寻找他们时间复杂度为O(1)
• 链表长度计数器，获取长度时间复杂度为O(1)

字典

字典，又称为符号表(symbol table) 、关联数组(associative .array)或映射(map) ，是一种用于保存键值对(key-value pair)的抽象数据结构。

哈希表

实现：哈希表

Redis的字典使用哈希表作为底层实现，一个哈希表里面可以有多个哈希表节点,而每个哈希表节点就保存了字典中的一个键值对。

相当于是一个哈希表，而不仅仅是哈希表的一个键值对

哈希表结构

/*
 * 哈希表
 *
 * 每个字典都使用两个哈希表，从而实现渐进式 rehash 。
 */
typedef struct dictht {
    
    // 哈希表数组，里面的元素是指向键值对的数组指针
    dictEntry **table;

    // 哈希表大小
    unsigned long size;
    
    // 哈希表大小掩码，用于计算索引值
    // 总是等于 size - 1
    unsigned long sizemask;

    // 该哈希表已有节点的数量
    unsigned long used;

} dictht;
/*
 * 哈希表节点: 键值对
 */
typedef struct dictEntry {
    
    // 键
    void *key;

    // 值，使用联合体更加省内存
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
    } v;

    // 指向下个哈希表节点，形成链表
    struct dictEntry *next;

} dictEntry;

字典原理

/*
 * 字典
 */
typedef struct dict {

    // 类型特定函数
    dictType *type;

    // 私有数据
    void *privdata;

    // 哈希表
    dictht ht[2];

    // rehash 索引
    // 当 rehash 不在进行时，值为 -1
    int rehashidx; /* rehashing not in progress if rehashidx == -1 */

    // 目前正在运行的安全迭代器的数量
    int iterators; /* number of iterators currently running */

} dict;
/*
 * 字典类型特定函数
 */
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;

ht属性是一个包含两个项的数组，数组中的每个项都是一个dictht哈希表，一般情况下， 字典只使用ht[0]哈希表，ht[1]哈希表只会在对ht[0]哈希表进行rehash时使用。（正常情况下是NULL）

哈希算法

// murmurhash算法
unsigned int (*hashFunction)(const void *key);

冲突
链地址法

rehash

随着操作的不断执行，哈希表保存的键值对会逐渐地增多或者减少，为了让哈希表的负载因子(load factor)维持在一个合理的范围之内，当哈希表保存的键值对数量太多或者太少时，程序需要对哈希表的大小进行相应的扩展或者收缩。

负载因子=used/size

• 为ht[1]分配空间，如果是扩充，扩充到ht[0]的两倍；如果是收缩，大于等于ht[0]已使用大小即可
• 将ht[0]键值对放到ht[1]上（使用copy-on-write技术）
• 是否ht[0]，ht[1]变成ht[0]，新建一个空白哈希表ht[1]

写时拷贝指的是并不完全复制，而是先让他们共享一块内存，当需要写入的时候，从而让他们都有自己的拷贝，也就是说，资源的赋值只有在需要写入的时候才进行，在此之前是以只读方式共享

渐进式rehash

数据量大的情况下不能直接复制，要一个一个来：（避免了集中式的庞大的计算量）

• 为ht[1]开辟内存
• 在字典中维持一个变量rehashidx（一般为-1），并将其设为0，开始工作
• 操作完成的时候rehashidx重新赋值-1