Redis常用数据类型及其对应的底层数据结构解析

791 阅读12分钟

前言

Redis是一种键值(key-Value)数据库,相对于关系型数据库,它也被叫作非关系型数据库。

Redis中,键的数据类型是字符串,但是为了非富数据存储方式,方便开发者使用,值的数据类型有很多。

一、SDS

1、SDS源码解读

sds (Simple Dynamic String),Simple的意思是简单,Dynamic即动态,意味着其具有动态增加空间的能力,扩容不需要使用者关心。String是字符串的意思。说白了就是用C语言自己封装了一个字符串类型,这个项目由Redis作者antirez创建,作为Redis中基本的数据结构之一。

sds有两个版本,在Redis3.2之前使用的是第一个版本,其数据结构如下所示:

typedef char *sds;      //注意,sds其实不是一个结构体类型,而是被typedef的char*

struct sdshdr {
    unsigned int len;   //buf中已经使用的长度
    unsigned int free;  //buf中未使用的长度
    char buf[];         //柔性数组buf
};

但是在Redis 3.2 版本中,对数据结构做出了修改,针对不同的长度范围定义了不同的结构,如下,这是目前的结构:

typedef char *sds;      

struct __attribute__ ((__packed__)) sdshdr5 {     // 对应的字符串长度小于 1<<5
    unsigned char flags; 
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {     // 对应的字符串长度小于 1<<8
    uint8_t len; /* used */                       // 目前字符创的长度,使用1个byte
    uint8_t alloc;                                // 已经分配的总长度,使用1个byte
    unsigned char flags;                          // flag用3bit来标明类型,类型后续解释,其余5bit目前没有使用。使用1byte。
    char buf[];                                   // 柔性数组,以'\0'结尾
};
struct __attribute__ ((__packed__)) sdshdr16 {    // 对应的字符串长度小于 1<<16
    uint16_t len; /* used,使用2byte */
    uint16_t alloc; /* excluding the header and null terminator,使用2byte */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {    // 对应的字符串长度小于 1<<32
    uint32_t len; /* used,使用4byte */
    uint32_t alloc; /* excluding the header and null terminator,使用4byte */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {    // 对应的字符串长度小于 1<<64
    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[];
};

2、SDS的特点

1.二进制安全的数据结构,不会产生数据的丢失

2.内存预分配机制,避免了频繁的内存分配。当字符串长度小于1M 时,扩容都是加倍现有的空间,如果超过1M,扩容时一次只会多扩1M 的空间。(字符串最大长度为512M)

3.兼容c语言函数库

二、Redis中几种数据结构

redisDb默认情况下有16个,每个redisDb内部包含一个dict的数据结构,dict内部包含dictht数组,数组个数为2,主要用于hash扩容使用。dictht内部包含dictEntry的数组,dictEntry其实就是hash表的一个key-value节点,如果冲突通过链地址法解决

1、redisServer

数据结构redisServer是一个redis服务端的抽象,定义在server.h中。 redisServer中的属性非常多,以下为节选的一部分,简单介绍下

struct redisServer {
    /* General */
    pid_t pid;                  /* Main process pid. */    
    ......  
    int hz;                     /* serverCron() calls frequency in hertz */
    redisDb *db;
    dict *commands;             /* Command table */
    dict *orig_commands;        /* Command table before command renaming. */
    aeEventLoop *el; 
    ...... 
    char runid[CONFIG_RUN_ID_SIZE+1];  /* ID always different at every exec. */ 
    ...... 
    list *clients;              /* List of active clients */
    list *clients_to_close;     /* Clients to close asynchronously */
    list *clients_pending_write; /* There is to write or install handler. */
    list *clients_pending_read;  /* Client has pending read socket buffers. */
    list *slaves, *monitors;    /* List of slaves and MONITORs */
    client *current_client;     /* Current client executing the command. */
    ......
};

1.hz: redis 定时任务触发的频率

2.*db: redisDb数组,默认16个redisDb

3.*commands: redis支持的命令的字典

4.*el: redis事件循环实例

5.runid[CONFIG_RUN_ID_SIZE+1]: 当前redis实例的runid

2、redisDb

redisDb是redis数据库的抽象,定义在server.h中,比较关键的属性如下:

typedef struct redisDb {
    dict *dict;                 /* 键值对字典,保存数据库中所有的键值对 */
    dict *expires;              /* 过期字典,保存着设置过期的键和键的过期时间*/
    dict *blocking_keys;        /*保存着 所有造成客户端阻塞的键和被阻塞的客户端 (BLPOP) */
    dict *ready_keys;           /* 保存着 处于阻塞状态的键,value为NULL*/
    dict *watched_keys;         /* 事物模块,用于保存被WATCH命令所监控的键 */
        // 当内存不足时,Redis会根据LRU算法回收一部分键所占的空间,而该eviction_pool是一个长为16数组,保存可能被回收的键
        // eviction_pool中所有键按照idle空转时间,从小到大排序,每次回收空转时间最长的键
    struct evictionPoolEntry *eviction_pool;    /* Eviction pool of keys */
    int id;                     /* 数据库ID */
    long long avg_ttl;          /* 键的平均过期时间 */
} redisDb;

3、dict

dict是redis中的字典,定义在dict.h文件中,其主要的属性如下:

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2]; //方便渐进的rehash扩容,dict的hashtable
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

1.ht[2]: 哈希表数组,为了扩容方便有2个元素,其中一个哈希表正常存储数据,另一个哈希表为空,空哈希表在rehash时使用

2.rehashidx:rehash索引,当不在进行rehash时,值为-1

4、dictht

dictht是哈希表结构,定义在dict.h文件中,其重要的属性如下:

typedef struct dictht {
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} dictht;

1.** table:key-value键值对节点数组,类似Java中的HashMap底层数组

2.size:哈希表容量大小

3.sizemask:总是等于size-1,用于计算索引值

4.used:哈希表实际存储的dictEntry数量

5、dictEntry

dictEntry是redis中的key-value键值对节点,是实际存储数据的节点,定义在dict.h文件中,其重要的属性如下:

typedef struct dictEntry {
    void *key;
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry *next;
} dictEntry;

1.*key:键对象,总是一个字符串类型的对象SDS

2.*val:值对象,可能是任意类型的对象。对应常见的5种数据类型:string,hash,list,set,zset

3.*next: 尾指针,指向下一个节点

三、数据类型

1、Redis数据对象结构

Redis数据库中所有数据都以key-value节点dictEntry存储,其中key和value都是一个redisObject结构体对象,只不过key总是一个字符串类型的对象(SDS),value则可能是任意一种数据类型的对象。

redisObject结构体定义在server.h中如下所示:

typedef struct redisObject {
    unsigned type:4;       //占用4bit
    unsigned encoding:4;   //占用4bit
    unsigned lru:LRU_BITS; /*占用24bit LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;          //占用4byte
    void *ptr;             //占用8byte  总空间:4bit+4bit+24bit+4byte+8byte = 16byte
} robj;

可以看到该结构体中重要的属性如下,不同的对象具有不同的类型type,同一个类型的type会有不同的存储形式encoding

1.type:该属性标明了数据对象的类型,比如 String,List等

2.encoding:这个属性指明了对象底层的存储结构,比如ZSet类型对象可能的存储结构有ZIPLIST和SKIPLIST

3.*ptr:指向底层存储结构的指针

2、Redis数据类型及存储结构

Redis中数据类型及其存储结构定义在server.h文件中

/* The actual Redis Object */
#define OBJ_STRING 0    /* String object. */
#define OBJ_LIST 1      /* List object. */
#define OBJ_SET 2       /* Set object. */
#define OBJ_ZSET 3      /* Sorted set object. */
#define OBJ_HASH 4      /* Hash object. */

#define OBJ_MODULE 5    /* Module object. */
#define OBJ_STREAM 6    /* Stream object. */

#define OBJ_ENCODING_RAW 0     /* Raw representation */
#define OBJ_ENCODING_INT 1     /* Encoded as integer */
#define OBJ_ENCODING_HT 2      /* Encoded as hash table */
#define OBJ_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
#define OBJ_ENCODING_LINKEDLIST 4 /* No longer used: old list encoding. */
#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define OBJ_ENCODING_INTSET 6  /* Encoded as intset */
#define OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
#define OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks */

四、Redis中常用数据类型和结构

  

1、字符串对象String

OBJ_STRING字符串对象底层数据结构一般为简单动态字符串(SDS),但其存储方式可以是OBJ_ENCODING_INT、OBJ_ENCODING_EMBSTR和 OBJ_ENCODING_RAW,不同的存储方式代表着对象内存结构的不同。

a)OBJ_ENCODING_INT

如果保存的字符串长度小于 20 并且可以解析为整数(值范围为:-2^63 ~ 2^63-1),那么这个整数就会直接保存在 redisObject 的 ptr 属性里

b)OBJ_ENCODING_EMBSTR

长度小于 44 (OBJ_ENCODING_EMBSTR_SIZE_LIMIT)的字符串将以简单动态字符串(SDS) 的形式存储,但是会使用 malloc 方法一次分配内存,将 redisObject 对象头和 SDS 对象连续存在一起。因为默认分配空间为64byte,而其中value为string类型采用sdshdr8中len、alloc、flags各占用1byte,buf以'\0'占用1byte,redisObject占用16字节,剩余buff可使用为64-4-16=44byte。

c)OBJ_ENCODING_RAW

字符串将以简单动态字符串(SDS)的形式存储,需要两次 malloc 分配内存,redisObject 对象头和 SDS 对象在内存地址上一般是不连续的

d)检测

#string类型查看redis的存储
SET key value                               //存入字符串键值对
STRLEN key                                  //查看key的长度(占用的byte字节)
OBJECT ENCODING key                         //查看key在redis中的存储类型
SETRANGE key offset value                   //修改key从offset(字符偏移量)字符修改为value,如果原本为embstr修改后也会变成raw。
GETRANGE key start end                      //获取key的部分值

2、列表对象list

OBJ_LIST列表对象的底层存储结构有过3种实现,分别是OBJ_ENCODING_LINKEDLIST、 OBJ_ENCODING_ZIPLIST和 OBJ_ENCODING_QUICKLIST,其中OBJ_ENCODING_LINKEDLIST在 3.2版本以后就废弃了。使用命令:OBJECT ENCODING key查看存储类型。

a)OBJ_ENCODING_LINKEDLIST

底层采用双端链表实现,每个链表节点都保存了一个字符串对象,在每个字符串对象内保存了一个元素。

b)OBJ_ENCODING_ZIPLIST

底层实现类似数组,使用特点属性保存整个列表的元信息,如整个列表占用的内存大小,列表保存的数据开始的位置,列表保存的数据的个数等,其保存的数据被封装在zlentry。

1.zlbytes:记录整个压缩列表占用的内存字节数。uint_32_t,4byte。

2.zltail:记录压缩列表表尾节点距离起始地址有多少字节,通过这个偏移量,程序无需遍历整个压缩列表就能确定表尾节点地址。uint_32_t,4byte。

3.zlen:记录压缩列表包含的节点数量。uint_16_t,2byte。

4.entryX:压缩列表的各个节点,节点长度由保存的内容决定。

5.zlend:特殊值(0xFFF),用于标记压缩列表末端。uint_8_t,1byte。

prerawlen:表示当前节点的前一个节点长度

len:当前节点的长度

data:当前节点的数据

c)OBJ_ENCODING_QUICKLIST

底层采用双端链表结构,不过每个链表节点都保存一个ziplist,数据存储在ziplist中

d)redis.conf配置

通过设置每个ziplist的最大容量,quicklist的数据压缩范围,提升数据存取效率。

list-max-ziplist-size-2 //单个ziplist节点最大能存储8kb,超过则进行分裂,将数据存储在新的ziplist节点中 list-compress-depth 0 //0代表所有节点,都不进行压缩。1,代表从头节点往后走一个,尾部节点往前走一个不用压缩,其他的全部压缩。

3、集合对象Set

OBJ_SET集合对象的底层存储结构有两种,OBJ_ENCODING_HT和OBJ_ENCODING_INTSET

a)OBJ_ENCODING_INTSET

typedef struct intset {
    uint32_t encoding;   //编码类型
    uint32_t length;       //元素个数
    int8_t contents[];     //元素数据
} intset;

//redis中保存整型的编码类型有int16_t,int32_t,int64_t
#define INTSET_ENC_INT16(sizeof(int16_t))
#define INTSET_ENC_INT32(sizeof(int32_t))
#define INTSET_ENC_INT64(sizeof(int64_t))

集合保存的所有元素都是整数值将会采用这种存储结构,但①当集合对象保存的元素数量超过512 (由server.set_max_intset_entries 配置)或者②元素无法用整型表示后会转化为OBJ_ENCODING_HT

b)OBJ_ENCODING_HT

底层为dict字典,数据作为字典的键保存,键对应的值都是NULL,与 Java 中的 HashSet 类似

4、有序集合ZSet

OBJ_ZSET 有序集合对象的存储结构分为 OBJ_ENCODING_SKIPLIST 和 OBJ_ENCODING_ZIPLIST

a)OBJ_ENCODING_ZIPLIST

当 ziplist 作为 zset 的底层存储结构时,每个集合元素使用两个紧挨在一起的压缩列表节点来保存,第一个节点保存元素值,第二个元素保存元素的分值,而且分值小的靠近表头,大的靠近表尾

有序集合对象使用 ziplist 存储需要同时满足以下两个条件,不满足任意一条件将使用 skiplist

所有元素长度小于64 (server.zset_max_ziplist_value配置)字节 元素个数小于128 (server.zset-max-ziplist-entries配置)

b)OBJ_ENCODING_SKIPLIST

底层实现是跳跃表结合字典。每个跳跃表节点都保存一个集合元素,并按分值从小到大排列,节点的object属性保存了元素的值,score属性保存分值;字典的每个键值对保存一个集合元素,元素值包装为字典的键,元素分值保存为字典的值。

skiplist同时使用跳跃表和字典实现的原因:

跳跃表优点是有序,但是查询分值时复杂度为O(logn);字典查询分值(zscore命令)复杂度为O(1) ,但是无序,结合两者可以实现优势互补集合的元素成员和分值是共享的,跳跃表和字典通过指针指向同一地址,不会浪费内存

5、哈希对象Hash

OBJ_HASH的存储结构分为OBJ_ENCODING_ZIPLIST和OBJ_ENCODING_HT(使用命令:OBJECT ENCODING key查看存储类型),其实现如下:

a)OBJ_ENCODING_ZIPLIST

在以ziplist结构存储数据的哈希对象中,key-value键值对以紧密相连的方式存入压缩链表,先把key放入表尾,再放入value;键值对总是向表尾添加。

哈希对象使用ziplist存储数据需要同时满足以下两个条件,不满足任意一个都使用dict结构 所有键值对的键和值的字符串长度都小于64 (server.hash_max_ziplist_value 配置)字节 键值对数量小于512(server.hash-max-ziplist-entries)个

 

b)OBJ_ENCODING_HT

底层为dict字典,哈希对象中的每个key-value对都使用一个字典键值对dictEntry来保存,字典的键和值都是字符串对象。

c)检测

HMSET key f1 v1 f2 v2 f3 v3                 //在一个哈希表key中存储多个键值对
OBJECT ENCODING key                         //查看key在redis中的存储类型为ziplist
HGETALL key                                 //查看key对应的所有field和value发现为有序的
HSET key f4 x...x                           //在一个哈希表key中存储一个长度超过64的value
HSTRLEN key f4                              //查看key中field为f4的长度
OBJECT ENCODING key                         //查看key在redis中的存储类型为hashtable
HGETALL key                                 //查看key对应的所有field和value发现为无序

最后

我这边整理了一份:Redis相关资料、Java的系统化资料:(包括Java核心知识点、面试专题和20年最新的互联网真题、电子书等)有需要的朋友可以关注公众号【程序媛小琬】即可获取。