01 Redis源码起航

源码解读

Redis 源码文件分布大致如下：

redisDb结构介绍

首先看下redisDb的结构，在server.h文件中：

typedef struct redisDb {
    dict *dict;                 /* 保存数据库中所有的键值对    */
    dict *expires;              /* 保存是所有有过期时间的键值对 */
    dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP) 客户端等待数据的键-客户端和键值的映射*/
    dict *ready_keys;           /* Blocked keys that received a PUSH */
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    int id;                     /* Database ID  数据库ID*/
    long long avg_ttl;          /* Average TTL, just for stats 平均TTL时间，仅用于统计*/
    unsigned long expires_cursor; /* Cursor of the active expire cycle. */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

• dict：保存db中所有的键值对
• expires：保存所有有过期时间的键值对
• expires_cursor:周期性删除过期键的游标，应该是6.0版本以后才有的，因为书里和网上的一些介绍都没有这个字段

typedef struct dict {
    dictType *type; /* 指定类型 */
    void *privdata;
    dictht ht[2];// ht[0] , ht[1] =null 两个 dictht 用于数据的扩容，渐进式重新散列
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

• dictType：指定的数据类型，中间可以指定hash函数
• dictht：hashtable的缩写，【2】在单线程的情况下扩容会影响响应应能造成卡顿，通过渐进式的方式对旧 hasht 槽位中的dictEntry进行数据迁移，没有请求的时候也会进行数据迁移，通过事件轮巡迁移数据，直到旧的数据迁移完。两个hashtable中的数据相互倒换。

typedef struct dictType {
    uint64_t (*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;

• hashFunction：指定hash函数
• keyCompare：类似于equals比较方法

/* 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; //  hashtable 容量 永远都是2的n次方
    unsigned long sizemask;  // 恒等于 size -1  对于任何 任意数%2^n 都 可以优化为位运算 任意数 & （2^n - 1） 原因是CUP对于任意数%2^n不友好
    unsigned long used;  // hashtable 元素个数   used / size =1  used ：size = 1：1 扩容
} dictht;

数据扩容逻辑

在元数个数与容量是1:1的时候回触发扩容，扩容逻辑是，请求访问key值的时候，如果dict对象中的dictht[0]存在key，那数据会迁移到dictht[1]中，如果dictht[0]中不存在，则访问dictht[1]中的数据，等到dictht[0]中数据迁移完成后，就把dictht[0]的指针指向dictht[1]，原有dictht[0]的指向null。redis数据扩容是成倍扩容的，扩容也是相互之前互相进行数据倒换。

typedef struct dictEntry {
    void *key;  // sds 对象，所有的key都是String类型
    union {
        void *val; //指针指向具体的数据，就是redis支持的几种数据类型。这里的数据也不是直接存储的，而是通过 redisObject 这个对象封装，甚至可以指定自定义的数据类型
        uint64_t u64;
        int64_t s64;
        double d;
    } v; // C语言的数据类型，用于存放value值
    struct dictEntry *next; // 链表，解决hash冲突，把产生hash冲突的节点关联起来
} dictEntry;







//  redisObject对象，对value的封装 :  string , list ,set ,hash ,zset ...
typedef struct redisObject {
    unsigned type:4;        //  4 bit, sting , hash 约束客户端的操作命令，基于客户端的操作命令，把数据封装为相应的数据结构，如 set->String, lpush->List
    unsigned encoding:4;    //  4 bit 编码类型，用于描述value值在数据库中的编码形式
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or 最近最少使用
                            * LFU data (least significant 8 bits frequency 最近不经常使用
                            * and most significant 16 bits access time). 
                            *    24 bit 
                            * */
    int refcount;           // 4 byte  引用计数法管理内存，没人使用时释放内存 
    void *ptr;              // 8 byte  总空间:  4 bit + 4 bit + 24 bit + 4 byte + 8 byte = 16 byte   真实存储数据的地方，指向数据在内存中的位置。
} robj;

typedef char *sds;

/* Note: sdshdr5 is never used, we just access the flags byte directly.
 * However is here to document the layout of type 5 SDS strings. */
struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];// buf[0]: z:  0101001
};
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* used */
    uint8_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[]; // 兼容C语言的函数库，会占用一个字节
};
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len; /* used */
    uint16_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[]; // 兼容C语言的函数库，会占用一个字节
};
struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* used */
    uint32_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[]; // 兼容C语言的函数库，会占用一个字节
};
struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len; /* used */
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

缓存值对象占用16个字节的总空间，内存中的缓存也是64个字节，一次读取64字节，还差48字节，那怎样让这48个字节进行补齐，让内存页地址是连续的呢？这里通过encoding这个字段确定具体的数据类型，那我们用那种类型的数据结构刚好是48个字节呢？我们从上面的String类型数据结构中可知，48个字节应该落在sdshdr8这个区间类，sds这个数据结构自身需要消耗4个字节，那还剩余44个字节，那我们存放一个44字节的数据，那正好可以占用64个字节，正好是一个缓存行的容量，这个时候数据类型是embstr，那我们读取内存数据时，可以一次读取出来。

Redis 里面小于等于44个字节的字符串是embstr编码、大于44个字节是raw编码

当字符串大于 44 字节时

SDS 的数据量就开始变多了，Redis 就不再把 SDS 和 RedisObject 布局在一起了，而是会给 SDS 分配独立的空间，并用指针指向 SDS 结构。 这种布局方式被称为 raw 编码模式。

 

RedisDb数据结构

redis 数据结构层次

第一个层面，是从使用者的角度。比如：

• string
• list
• hash
• set
• sorted set

这一层面也是Redis暴露给外部的调用接口。

第二个层面，是从内部实现的角度，属于更底层的实现。比如：

• dict
• sds
• ziplist
• quicklist
• skiplist

第一个层面的“数据结构”，Redis的官方文档(An introduction to Redis data types and abstractions – Redis)有详细的介绍。本文的重点在于讨论第二个层面，Redis数据结构的内部实现，以及这两个层面的数据结构之间的关系：Redis如何通过组合第二个层面的各种基础数据结构来实现第一个层面的更高层的数据结构。

思考：

1 redis的扩容机制是如何实现的？

redis在hashtable容量与其中的容量是1:1的时候回触发redis的扩容机制，扩容机制触发后，每当有请求过来的时候都会去原有的hashtable中查找是否有当前查询的key存在，如果存在则把当前的数据迁移到因扩容的hashtable中，然后返回数据；如果原有的hashtable不存在当前key的值，则直接去新的hashtable中查询数据并返回。

2 redis key 的hash冲突是怎么解决的？

redis在存放key=AAA的时候，如果hashtable没有hase(AAA)的下标，则值直接存放在槽位下面，如果有冲突则把值存放在槽位下面，并通过链表的方式把产生冲突的值用链表串起来。

3 redis是如何替换原有key值的？

在上一个问题的基础上，通过遍历链表，比较key值。

3 redis 的数据类型为什么

参考：

1 第十章：Redis中bitmap的妙用 - 唯伊 - 博客园