Redis底层数据结构详解

redis作为key-value存储系统,数据结构如下:

redis没有表的概念,redis实例所对应的db以编号区分,db本身就是key的命名空间。

比如:user:1000作为key值,表示在user这个命名空间下id为1000的元素,类似于user表的id=1000的行。

redisdb结构

redis中存在“数据库”的概念,该结构由redis.h中的redisdb定义。

当redis 服务器初始化时,会预先分配 16 个数据库

所有数据库保存到结构 redisserver 的一个成员 redisserver.db 数组中

redisclient中存在一个名叫db的指针指向当前使用的数据库

redisdb结构体源码:

/* 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. */
typedef struct redisdb {
    dict *dict;                 /* 存储数据库所有的key-value */
    dict *expires;              /* 存储key的过期时间 */
    dict *blocking_keys;        /* blpop 存储阻塞key和客户端对象*/
    dict *ready_keys;           /* 阻塞后push 响应阻塞客户端 存储阻塞后push的key和客户端对象 */
    dict *watched_keys;         /* 存储watch监控的的key和客户端对象 */
    int id;                     /* database id */
    long long avg_ttl;          /* 存储的数据库对象的平均ttl(time to live),用于统计 */
    unsigned long expires_cursor; /* 循环过期检查的光标. */
    list *defrag_later;         /* 需要尝试去清理磁盘碎片的链表,会慢慢的清理 */
} redisdb;

id
id是数据库序号,为0-15(默认redis有16个数据库)

dict
存储数据库所有的key-value,后面要详细讲解

expires
存储key的过期时间,后面要详细讲解

redisobject结构

value是一个对象
包含字符串对象,列表对象,哈希对象,集合对象和有序集合对象

结构信息概览

typedef struct redisobject {
    unsigned type:4; //类型 对象类型
    unsigned encoding:4;//编码
	// lru_bits为24bit 记录最后一次被命令程序访问的时间
    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). */
    int refcount; //引用计数
    void *ptr;//指向底层实现数据结构的指针
} robj;

4位type

type 字段表示对象的类型,占 4 位;

redis_string(字符串)、redis_list (列表)、redis_hash(哈希)、redis_set(集合)、redis_zset(有序集合)。

当我们执行 type 命令时,便是通过读取 redisobject 的 type 字段获得对象的类型

127.0.0.1:6379> set a1 111
ok
127.0.0.1:6379> type a1
string

4位encoding

encoding 表示对象的内部编码,占 4 位

每个对象有不同的实现编码

redis 可以根据不同的使用场景来为对象设置不同的编码,大大提高了 redis 的灵活性和效率。

通过 object encoding 命令,可以查看对象采用的编码方式

127.0.0.1:6379> object encoding a1
"int"

24位lru
lru 记录的是对象最后一次被命令程序访问的时间,( 4.0 版本占 24 位,2.6 版本占 22 位)。

高16位存储一个分钟数级别的时间戳,低8位存储访问计数(lfu : 最近访问次数)

   lru—-> 高16位: 最后被访问的时间

   lfu—–>低8位:最近访问次数

refcount
refcount 记录的是该对象被引用的次数,类型为整型。

refcount 的作用,主要在于对象的引用计数和内存回收。

当对象的refcount>1时,称为共享对象

redis 为了节省内存,当有一些对象重复出现时,新的程序不会创建新的对象,而是仍然使用原来的对象。

ptr
ptr 指针指向具体的数据,比如:set hello world,ptr 指向包含字符串 world 的 sds。

7种type 字符串对象

c语言: 字符数组 “\0”

redis 使用了 sds(simple dynamic string)。用于存储字符串和整型数据。

/* 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[];};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 {    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[];};

buf[] 的长度=len+free+1

sds的优势:

1.sds 在 c 字符串的基础上加入了 free 和 len 字段,获取字符串长度:sds 是 o(1),c 字符串是
o(n)。
buf数组的长度=free+len+1

2.sds 由于记录了长度,在可能造成缓冲区溢出时会自动重新分配内存,杜绝了缓冲区溢出。

3.可以存取二进制数据,以字符串长度len来作为结束标识

  • c:

\0 空字符串 二进制数据包括空字符串,所以没有办法存取二进制数据

  • sds :

非二进制 \0
二进制: 字符串长度 可以存二进制数据

使用场景:
sds的主要应用在:存储字符串和整型数据、存储key、aof缓冲区和用户输入缓冲。

跳跃表(重要)

跳跃表是有序集合(sorted-set)的底层实现,效率高,实现简单。

跳跃表的基本思想:

将有序链表中的部分节点分层,每一层都是一个有序链表。

查找

在查找时优先从最高层开始向后查找,当到达某个节点时,如果next节点值大于要查找的值或next指针指向null,则从当前节点下降一层继续向后查找。

举例:

查找元素9,按道理我们需要从头结点开始遍历,一共遍历8个结点才能找到元素9。

第一次分层:

遍历5次找到元素9(红色的线为查找路径)

第二次分层:

遍历4次找到元素9

第三层分层:

遍历4次找到元素9

这种数据结构,就是跳跃表,它具有二分查找的功能。

插入与删除

上面例子中,9个结点,一共4层,是理想的跳跃表。

通过抛硬币(概率1/2)的方式来决定新插入结点跨越的层数,每层都需要判断:

正面:插入上层

背面:不插入

达到1/2概率(计算次数)

删除

找到指定元素并删除每层的该元素即可

跳跃表特点:

每层都是一个有序链表

查找次数近似于层数(1/2)

底层包含所有元素

空间复杂度 o(n) 扩充了一倍

redis跳跃表的实现

/* zsets use a specialized version of skiplists */
typedef struct zskiplistnode {
    /* 存储字符串类型数据 redis3.0版本中使用robj类型表示,但是在redis4.0.1中直接使用sds类型表示 */
    sds ele;
    /*存储排序的分值*/
    double score;
    /*后退指针,指向当前节点最底层的前一个节点*/
    struct zskiplistnode *backward;
    /*层,柔性数组,随机生成1-64的值*/
    struct zskidictentryplistlevel {
        struct zskiplistnode *forward; //指向本层下一个节点
        unsigned long span; //本层下个节点到本节点的元素个数
    } level[];
} zskiplistnode;

typedef struct zskiplist {
    //表头节点和表尾节点
    struct zskiplistnode *header, *tail;
    //表中节点的数量
    unsigned long length;
    //表中层数最大的节点的层数
    int level;
} zskiplist;

完整的跳跃表结构体:

跳跃表的优势:
1、可以快速查找到需要的节点 o(logn)
2、可以在o(1)的时间复杂度下,快速获得跳跃表的头节点、尾结点、长度和高度。
应用场景:有序集合的实现

字典(重要)

字典dict又称散列表(hash),是用来存储键值对的一种数据结构。
redis整个数据库是用字典来存储的。(k-v结构)
对redis进行curd操作其实就是对字典中的数据进行curd操作。

数组

数组:用来存储数据的容器,采用头指针+偏移量的方式能够以o(1)的时间复杂度定位到数据所在的内存地址。

redis 海量存储 快

hash函数

hash(散列),作用是把任意长度的输入通过散列算法转换成固定类型、固定长度的散列值。

hash函数可以把redis里的key:包括字符串、整数、浮点数统一转换成整数。

key=100.1 string “100.1” 5位长度的字符串

redis-cli :times 33

redis-server : murmurhash

数组下标=hash(key)%数组容量(hash值%数组容量得到的余数)

hash冲突

不同的key经过计算后出现数组下标一致,称为hash冲突。

采用单链表在相同的下标位置处存储原始key和value

当根据key找value时,找到数组下标,遍历单链表可以找出key相同的value

redis字典的实现

redis字典实现包括:字典(dict)、hash表(dictht)、hash表节点(dictentry)。

hash表

typedef struct dictht {
    dictentry **table; // 哈希表数组
    unsigned long size; // 哈希表数组的大小
    unsigned long sizemask; // 用于映射位置的掩码,值永远等于(size-1)
    unsigned long used; // 哈希表已有节点的数量,包含next单链表数据
} dictht;

1、hash表的数组初始容量为4,随着k-v存储量的增加需要对hash表数组进行扩容,新扩容量为当前量的一倍,即4,8,16,32

2、索引值=hash值&掩码值(hash值与hash表容量取余)

hash表节点

typedef struct dictentry {
    void *key; // 键
    union { // 值v的类型可以是以下4种类型
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictentry *next; // 指向下一个哈希表节点,形成单向链表 解决hash冲突, 单链表中会存储key和value
} dictentry;

key字段存储的是键值对中的键

v字段是个联合体,存储的是键值对中的值。

next指向下一个哈希表节点,用于解决hash冲突

dict字典

typedef struct dict {
    dicttype *type; //该字典对应的特定操作函数
    void *privdata; //上述类型函数对应的可选参数
    dictht ht[2];/* 两张哈希表,存储键值对数据,ht[0]为原生哈希表,ht[1]为 rehash 哈希表 */
    long rehashidx; /* rehash标识 当等于-1时表示没有在rehash,否则表示正在进行rehash操作,
    				存储的值表示hash表 ht[0]的rehash进行到哪个索引值(数组下标)*/
    unsigned long iterators; /* 当前运行的迭代器数量 */
} dict;

type字段,指向dicttype结构体,里边包括了对该字典操作的函数指针

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;

  redis字典除了主数据库的k-v数据存储以外,还可以用于:散列表对象、哨兵模式中的主从节点管理等在不同的应用中,字典的形态都可能不同,dicttype是为了实现各种形态的字典而抽象出来的操作函数(多态)。

完整的redis字典数据结构:

字典扩容

字典达到存储上限(阈值 0.75),需要rehash(扩容)

说明:

初次申请默认容量为4个dictentry,非初次申请为当前hash表容量的一倍。rehashidx=0表示要进行rehash操作。新增加的数据在新的hash表h[1]修改、删除、查询在老hash表h[0]、新hash表h[1]中(rehash中)将老的hash表h[0]的数据重新计算索引值后全部迁移到新的hash表h[1]中,这个过程称为rehash。 渐进式rehash

当数据量巨大时rehash的过程是非常缓慢的,所以需要进行优化。
服务器忙,则只对一个节点进行rehash
服务器闲,可批量rehash(100节点)
应用场景:
1、主数据库的k-v数据存储
2、散列表对象(hash)
3、哨兵模式中的主从节点管理

压缩列表

压缩列表(ziplist)是由一系列特殊编码的连续内存块组成的顺序型数据结构

节省内存
是一个字节数组,可以包含多个节点(entry)。每个节点可以保存一个字节数组或一个整数。

压缩列表的数据结构如下:

zlbytes:压缩列表的字节长度
zltail:压缩列表尾元素相对于压缩列表起始地址的偏移量
zllen:压缩列表的元素个数
entry1…entryx : 压缩列表的各个节点
zlend:压缩列表的结尾,占一个字节,恒为0xff(255)
entryx元素的编码结构:

previous_entry_length:前一个元素的字节长度
encoding:表示当前元素的编码
content:数据内容

ziplist结构体如下:

struct ziplist<t>{
    unsigned int zlbytes; // ziplist的长度字节数,包含头部、所有entry和zipend。
    unsigned int zloffset; // 从ziplist的头指针到指向最后一个entry的偏移量,用于快速反向查询
    unsigned short int zllength; // entry元素个数t[] entry; // 元素值
    unsigned char zlend; // ziplist结束符,值固定为0xff
}
typedef struct zlentry {
    unsigned int prevrawlensize; //previous_entry_length字段的长度
    unsigned int prevrawlen; //previous_entry_length字段存储的内容
    unsigned int lensize; //encoding字段的长度
    unsigned int len; //数据内容长度
    unsigned int headersize; //当前元素的首部长度,即previous_entry_length字段长度与 encoding字段长度之和。
    unsigned char encoding; //数据类型
    unsigned char *p; //当前元素首地址
} zlentry;

应用场景:
sorted-set和hash元素个数少且是小整数或短字符串(直接使用)

list用快速链表(quicklist)数据结构存储,而快速链表是双向列表与压缩列表的组合。(间接使用)

整数集合

整数集合(intset)是一个有序的(整数升序)、存储整数的连续存储结构。
当redis集合类型的元素都是整数并且都处在64位有符号整数范围内(-2^63 ~ 2^63 -1 ),使用该结构体存储。

127.0.0.1:6379> sadd set:1 12  6  8
(integer) 3
127.0.0.1:6379> object encoding set:1
"intset"
127.0.0.1:6379> sadd set:2 1 1000000000000000000000000000000000000000000000000000000 99999999999999999999999999999
(integer) 3
127.0.0.1:6379> object encoding set:2
"hashtable"

intset的结构图如下:

typedef struct intset{    //编码方式    uint32_t encoding;    //集合包含的元素数量    uint32_t length;    //保存元素的数组    int8_t contents[];}intset;

应用场景:
可以保存类型为int16_t、int32_t 或者int64_t 的整数值,并且保证集合中不会出现重复元素。

快速列表(重要)

  快速列表(quicklist)是redis底层重要的数据结构。是列表的底层实现。(在redis3.2之前,redis采用双向链表(adlist)和压缩列表(ziplist)实现。)在redis3.2以后结合adlist和ziplist的优势redis设计出了quicklist。

127.0.0.1:6379> lpush list:001  2 3 5 6 7
(integer) 5
127.0.0.1:6379> object encoding list:001
"quicklist"

双向列表(adlist)

双向链表优势:

  1. 双向:链表具有前置节点和后置节点的引用,获取这两个节点时间复杂度都为o(1)。
  2. 普通链表(单链表):节点类保留下一节点的引用。链表类只保留头节点的引用,只能从头节点插入删除
  3. 无环:表头节点的 prev 指针和表尾节点的 next 指针都指向 null,对链表的访问都是以 null 结束。
  4. 环状:头的前一个节点指向尾节点
  5. 带链表长度计数器:通过 len 属性获取链表长度的时间复杂度为 o(1)。
  6. 多态:链表节点使用 void* 指针来保存节点值,可以保存各种不同类型的值。

快速列表
quicklist是一个双向链表,链表中的每个节点时一个ziplist结构。quicklist中的每个节点ziplist都能够存储多个数据元素。

quicklist的结构定义如下:

#if uintptr_max == 0xffffffff
/* 32-bit */
#   define ql_fill_bits 14
#   define ql_comp_bits 14
#   define ql_bm_bits 4
#elif uintptr_max == 0xffffffffffffffff
/* 64-bit */
#   define ql_fill_bits 16
#   define ql_comp_bits 16
#   define ql_bm_bits 4 /* we can encode more, but we rather limit the user
                           since they cause performance degradation. */
#else
#   error unknown arch bits count
#endif

/* quicklist is a 40 byte struct (on 64-bit systems) describing a quicklist.
 * 'count' is the number of total entries.
 * 'len' is the number of quicklist nodes.
 * 'compress' is: 0 if compression disabled, otherwise it's the number
 *                of quicklistnodes to leave uncompressed at ends of quicklist.
 * 'fill' is the user-requested (or default) fill factor.
 * 'bookmakrs are an optional feature that is used by realloc this struct,
 *      so that they don't consume memory when not used. */
typedef struct quicklist {
    quicklistnode *head; // 指向quicklist的头部
    quicklistnode *tail; // 指向quicklist的尾部
    unsigned long count;        /* 列表中所有数据项的个数总和 */
    unsigned long len;          /* quicklist节点的个数,即ziplist的个数 */
    int fill : ql_fill_bits;              /* ziplist大小限定,由list-max-ziplist-size给定  (redis设定)*/
    unsigned int compress : ql_comp_bits; /* depth of end nodes not to compress;0=off */
    unsigned int bookmark_count: ql_bm_bits; /*节点压缩深度设置,由list-compress-depth给定*/
    quicklistbookmark bookmarks[]; /*可选新特性 使用realloc重新分配空间的时候会用到*/
} quicklist;

quicklistnode的结构定义如下:

/* quicklistnode is a 32 byte struct describing a ziplist for a quicklist.
 * we use bit fields keep the quicklistnode at 32 bytes.
 * count: 16 bits, max 65536 (max zl bytes is 65k, so max count actually < 32k).
 * encoding: 2 bits, raw=1, lzf=2.
 * container: 2 bits, none=1, ziplist=2.
 * recompress: 1 bit, bool, true if node is temporary decompressed for usage.
 * attempted_compress: 1 bit, boolean, used for verifying during testing.
 * extra: 10 bits, free for future use; pads out the remainder of 32 bits */
typedef struct quicklistnode {
    struct quicklistnode *prev; // 指向上一个ziplist节点
    struct quicklistnode *next; // 指向下一个ziplist节点
    unsigned char *zl; // 数据指针,如果没有被压缩,就指向ziplist结构,反之指向 quicklistlzf结构
    unsigned int sz; // 表示指向ziplist结构的总长度(内存占用长度)
    unsigned int count : 16; // 表示ziplist中的数据项个数
    unsigned int encoding : 2; // 编码方式,1--ziplist,2--quicklistlzf
    unsigned int container : 2; // 预留字段,存放数据的方式,1--none,2--ziplist
    unsigned int recompress : 1; // 解压标记,当查看一个被压缩的数据时,需要暂时解压,标记此参数为 1,之后再重新进行压缩
    unsigned int attempted_compress : 1; // 测试相关
    unsigned int extra : 10; // 扩展字段,暂时没用
} quicklistnode;

数据压缩
  quicklist每个节点的实际数据存储结构为ziplist,这种结构的优势在于节省存储空间。为了进一步降低ziplist的存储空间,还可以对ziplist进行压缩。redis采用的压缩算法是lzf。其基本思想是:数据与前面重复的记录重复位置及长度,不重复的记录原始数据。

  压缩过后的数据可以分成多个片段,每个片段有两个部分:解释字段和数据字段。quicklistlzf的结构体如下:

/* quicklistlzf is a 4+n byte struct holding 'sz' followed by 'compressed'.
 * 'sz' is byte length of 'compressed' field.
 * 'compressed' is lzf data with total (compressed) length 'sz'
 * note: uncompressed length is stored in quicklistnode->sz.
 * when quicklistnode->zl is compressed, node->zl points to a quicklistlzf */
typedef struct quicklistlzf {
    unsigned int sz; /* lzf压缩后占用的字节数*/
    char compressed[]; //柔性数组,指向数据部分
} quicklistlzf;

应用场景
列表(list)的底层实现、发布与订阅、慢查询、监视器等功能。

流对象

stream主要由:消息、生产者、消费者和消费组构成。

redis stream的底层主要使用了listpack(紧凑列表)和rax树(基数树)。

listpack
listpack表示一个字符串列表的序列化,listpack可用于存储字符串或整数。用于存储stream的消息内容。
结构如下图:

rax树
rax 是一个有序字典树 (基数树 radix tree),按照 key 的字典序排列,支持快速地定位、插入和删除操作。

  

rax 被用在 redis stream 结构里面用于存储消息队列,在 stream 里面消息 id 的前缀是时间戳 + 序号,这样的消息可以理解为时间序列消息。使用 rax 结构 进行存储就可以快速地根据消息 id 定位到具体的消息,然后继续遍历指定消息 之后的所有消息。

应用场景:
stream的底层实现

10种encoding

/* objects encoding. some kind of objects like strings and hashes can be
 * internally represented in multiple ways. the 'encoding' field of the object
 * is set to one of this fields for this 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 */

encoding 表示对象的内部编码,占 4 位。

redis通过 encoding 属性为对象设置不同的编码

对于少的和小的数据,redis采用小的和压缩的存储方式,体现redis的灵活性

大大提高了 redis 的存储量和执行效率

比如set对象:

intset : 元素是64位以内的整数

hashtable:元素是64位以外的整数

127.0.0.1:6379> sadd set:001 1 3 5 6 2
(integer) 5
127.0.0.1:6379> object encoding set:001
"intset"
127.0.0.1:6379> sadd set:004 1 100000000000000000000000000 9999999999
(integer) 3
127.0.0.1:6379> object encoding set:004
"hashtable"

string

int、raw、embstr

int

redis_encoding_int(int类型的整数)

127.0.0.1:6379> set n1 123
ok
127.0.0.1:6379> object encoding n1
"int"

embstr

redis_encoding_embstr(编码的简单动态字符串)
小字符串 长度小于44个字节

127.0.0.1:6379> set name:001 zhangfei
ok
127.0.0.1:6379> object encoding name:001
"embstr"

raw

redis_encoding_raw (简单动态字符串)
大字符串 长度大于44个字节

127.0.0.1:6379> set address:001 asdasdasdasdasdasdsadasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdas
ok
127.0.0.1:6379> object encoding address:001
"raw"

list

列表的编码是quicklist。
redis_encoding_quicklist(快速列表)

127.0.0.1:6379> lpush list:001 1 2 5 4 3
(integer) 5
127.0.0.1:6379> object encoding list:001
"quicklist"

hash

散列的编码是字典和压缩列表

dict

redis_encoding_ht(字典)
当散列表元素的个数比较多或元素不是小整数或短字符串时。

127.0.0.1:6379> hmset user:003 username111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111 zhangfei password 111 num 2300000000000000000000000000000000000000000000000000
ok
127.0.0.1:6379> object encoding user:003
"hashtable"

ziplist

redis_encoding_ziplist(压缩列表)
当散列表元素的个数比较少,且元素都是小整数或短字符串时。

127.0.0.1:6379> hset user:001 username zhanyun password 123456
(integer) 2
127.0.0.1:6379> object encoding user:001
"ziplist"

set

集合的编码是整形集合和字典

intset

redis_encoding_intset(整数集合)
当redis集合类型的元素都是整数并且都处在64位有符号整数范围内(-9223372036854775808 ~ 9223372036854775807)

127.0.0.1:6379> sadd set:001 1 3 5 6 2
(integer) 5
127.0.0.1:6379> object encoding set:001
"intset"

dict

redis_encoding_ht(字典)
当redis集合类型的元素是非整数或都处在64位有符号整数范围外(>9223372036854775807)

127.0.0.1:6379> sadd set:004 1 100000000000000000000000000 9999999999
(integer) 3
127.0.0.1:6379> object encoding set:004
"hashtable"

zset

有序集合的编码是压缩列表和跳跃表+字典

ziplist

redis_encoding_ziplist(压缩列表)

当元素的个数比较少,且元素都是小整数或短字符串时。

127.0.0.1:6379> zadd hit:1 100 item1 20 item2 45 item3
(integer) 3
127.0.0.1:6379> object encoding hit:1
"ziplist"

skiplist + dict

redis_encoding_skiplist(跳跃表+字典)

当元素的个数比较多或元素不是小整数或短字符串时。

127.0.0.1:6379> zadd hit:2 100 item1111111111111111111111111111111111111111111111111111111111111111111111111111 1111111111111111111111111111111111 20 item2 45 item3
(integer) 3
127.0.0.1:6379> object encoding hit:2
"skiplist"

到此这篇关于redis底层数据结构的文章就介绍到这了,更多相关redis数据结构内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com!

(0)
上一篇 2022年3月21日
下一篇 2022年3月21日

相关推荐