Redis数据结构分析（一）

姑苏冷

已于 2022-07-21 21:05:51 修改

阅读量476

点赞数

分类专栏： redis 文章标签： redis java 数据库

于 2022-07-21 20:30:13 首次发布

本文链接：https://blog.csdn.net/A7_A8_A9/article/details/125830011

版权

redis 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

redis的源码是用c语言写的。

key的存储方式

我们在redis中无论使用哪种数据结构，比如string,map,list 等，都有一个key,而且这个key可以使用数字，字符，浮点数都可以。

set 0.8 UI
set 99  HU
set prd1 HB

只所以使用哪种方式都可以，是因为redis存储key的时候是用的c语言中的char数据类型存储的，但是又不是直接使用 char [] 存储，而是自己包装了一个数据结构：SDS(simple dynamic string)

这个数据结构里面主要有：

SDS :
  int free  # 表示还剩余多少个字符可以存储
  int len # 表示字符串的总长度是多少
  char buf[] #存储字符串，还是使用的字符数组

那它为啥不直接使用char []存储呢，主要有如下原因：

1：使用SDS结构存储，可以保证二进制数据也可以作为key存储。

这是因为在c语言中char [] 的最后一位会默认加上\0的标识，如果是个二进制数据里面免不了有\0的标识，如果直接使用char []存储，会出现丢数据的情况。

2：提供了内存预分配机制，避免频繁的内存分配。

这一点有点类似Java中的集合扩容。在redis中可能会出现key字符串的追加。根据free的数字可以判断char []是否进行扩容，如果需要扩容的话，直接进行(len+addlen(追加的长度))*2 来进行扩容。

3：兼容c语言的函数库。char []末尾追加\0。

但是对于上述提到的数据结构中的 int len,int free 都是int类型，可以表示的字符长度达到0~2^32-1,这个长度已经很大了，但是对于一般使用的key根本不用这么长，短的key使用这个int数据类型也是浪费空间，所以在3.2版本之后根据不同长度的key有了不同的存储结构。

数据结构

redis 3.2 以前
struct sdshdr {
    int len;
    int free;
    char buf[];
};
redis 3.2 后

typedef char *sds;

struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];
};
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[];
};
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[];
};
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[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
........

value的存储方式

看过了key存储结构就是个string，redis中的value 有好几种数据类型：string,hash,set,sorted set ,list。了解value的数据结构对于后续不同数据结构的使用场景和优化就会更清楚些。

对于redis来说是个键值对的数据库，分开来说分为键值对，数据库。在redis中键值对是用dict结构存储的。对于单机的redis实例来讲，默认有16个db,分为0~15个索引位。

在redis中db是用redisDb这个结构存储的：在server.h文件中：

/* Redis database representation. There are multiple databases identified
 * by integers from 0 (the default database) up to the max configured
 * database. The database number is the 'id' field in the structure. */
// Redis DB 
typedef struct redisDb {
    dict *dict;                 /* The keyspace for this DB  k-v结构存储的内容存储  */
    dict *expires;              /* Timeout of keys with a timeout set    过期时间字典 */
    dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP) 客户端和key之间的绑定关系*/
    dict *ready_keys;           /* Blocked keys that received a PUSH */
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    int id;                     /* Database ID 数据库的id 比如 0~15*/
    long long avg_ttl;          /* Average TTL, just for stats */
    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，相当于是hash table了。

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2];  // 有两个实例作为hash table 结构，为了扩容的时候进行渐进式的rehash
                   // 当数据量很大的时候需要进行扩容的时候，不能一下子复制原始数据到新数组里面，
                   // 当访问到某个key的时候就把某个key移动到新的数组中，就算 某段时间内没有key的访问，也有
                   // 后台任务在一点一点移动key到新数组中，直到老的数组里面的数据搬空进行释放。
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

typedef struct dictType {
    uint64_t (*hashFunction)(const void *key);  // hash函数 可以指定
    void *(*keyDup)(void *privdata, const void *key);
    void *(*valDup)(void *privdata, const void *obj);
    int (*keyCompare)(void *privdata, const void *key1, const void *key2); // 相当于equal方法
    void (*keyDestructor)(void *privdata, void *key);
    void (*valDestructor)(void *privdata, void *obj);
} dictType;

/* 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; // 具体的key-value数据存储在这里面
    unsigned long size;
    unsigned long sizemask;  // size -1
    unsigned long used;
} dictht;

看下真正存储key-value的结构：dictEntry

typedef struct dictEntry {
    void *key;  //void 空指针，表示这个指针并不是指向某个具体的类型，可以指向任意的类型  指向key的指针，指向string类型的，就是sds实例
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v; // value存储在这里，只会用到union 里面的一个属性。在key-value存储的时候 用 void *val，val就是指向redis中的string,list,hash,set数据类型的
         // 实例，这些基本的数据类型也都封装成了 redisObject 实例 
    struct dictEntry *next;  // hash存在冲突的时候，会放在链表中，指向下一个节点。
} dictEntry;

//  redisObject对象 :  string , list ,set ,hash ,zset ...
typedef struct redisObject {
    unsigned type:4;        //  4 bit, 数据类型： sting , hash，list等类型，可以约束客户端命令，因为同一个key 进行设置的时候类型就确定了
    unsigned encoding:4;    //  4 bit  redis使用的编码格式和优化有关 后面讲述
    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  redis中使用引用计数法来管理内存
    void *ptr;              // 8 byte  总空间:  4 bit + 4 bit + 24 bit + 4 byte + 8 byte = 16 byte 具体指向value的地址值
} robj;

上述几种结构的关系：

string类型的结构

使用set命令设置三个key-value数据：

通过type命令查看三个key类型都是string的。

通过object encoding 命令查看这三个key的value却是不同的:

这三种类型有什么不同呢？看下redis里面对于这三个value值是怎么处理的。

在server.c中 redisCommand 定义着客户端使用的一些命令：

看下setCommand里的操作：有一步就是对value进行编码的

int: 类型的判断依据

o->ptr = (void*) value;可以节省空间还可以减少一次寻址操作。

embstr又是怎么样的呢？嵌入式string,这个嵌入是怎么来的呢

这个主要是从读取数据性能方面来考虑实现的，和cpu读取数据有关。

先来了解下缓存行（详细解释和数据交换过程，网上都有介绍），由于cpu和内存的读取数据的速度不在一个量级上，所以cpu和内存交换数据之间通过了三级缓存来处理，cpu从内存中读取数据的大小单位就是缓存行，就是一次从内存读取多大的数据到缓存里面，现在都是64位机，一个缓存行就是64字节。

我们知道redis中的key-value中的value是用redisObject结构存储的，那它一个实例占多少字节呢？

//  redisObject对象 :  string , list ,set ,hash ,zset ...
typedef struct redisObject {
    unsigned type:4;        //  4 bit, 数据类型： sting , hash，list等类型，可以约束客户端命令，因为同一个key 进行设置的时候类型就确定了
    unsigned encoding:4;    //  4 bit  redis使用的编码格式和优化有关 后面讲述
    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  redis中使用引用计数法来管理内存
    void *ptr;              // 8 byte  总空间:  4 bit + 4 bit + 24 bit + 4 byte + 8 byte = 16 byte 具体指向value的地址值
} robj;

根据里面的属性，推断一个redisObject占16个字节，缓存行64个字节，还有48个字节没用到，如果不使用，这部分空间，还会通过*ptr地址指针来查找具体的数据，多了一次寻址，这里用的就是sds结构和redisObject结构紧凑排列，占用后面的48个字节，这样就可以在一个缓存行里被cpu读取到，但是sds结构只能用sdshdr8了因为剩余48字节超过了2^5-1（sdshdr5），sdshr8本身占用了三个字节，外加一个数组末尾自动加的\0,所以能够存储字符的空间剩下44字节了。

struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* used 8bit */
    uint8_t alloc; /* 8bit excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];  // 数组末尾会自动加上 \0 占一个字节
};

缓存行（64字节）=redisObject实例(16字节)+sds(4字节)+sds中的真正能存储字符的数组（44字节）

这样紧凑的排列，可以提升读取性能。所以当key-value中的value小于44字节的时候会用embstr编码。

127.0.0.1:8001> set str88 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
OK
127.0.0.1:8003> object encoding str88
"embstr"
127.0.0.1:8003> set str45 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
OK
127.0.0.1:8002> object encoding str45
"raw"

当大于45的时候就使用raw的编码了，redisObject和具体的数据不处于同一个缓存行，会增加一次数据读取。

注意：redis中string最大存储值是512M.