渐进式解析 Redis 源码 - 对象 object

阅读量

此 承前 数据结构，启后 数据类型

前面我们介绍了 各种数据结构 ( sds、dict、skiplist、intset、ziplist 等 )，作为 Redis 对外提供的 各种数据类型的 底层组成部分；但是 各种数据类型的 键值对 并不是直接使用 这些数据结构，而是基于这些 数据结构 构建了一个 对象系统 ( 字符串对象、列表对象、哈希对象、集合对象 、有序集合对象 )，每种对象都 至少使用了一种 我们之前提到的 数据结构

对象的有如下特性

  • Redis 在执行命令之前，根据对象的类型就可以判断 命令是否可以执行
  • 依托对象，可以针对不同的使用场景，为对象设置不同的数据结构实现，从而优化对象在不同场景下的使用效率
  • Redis 对象系统实现了基于引用计数技术的内存回收机制，当程序不再使用某个对象的时候，这个对象所占用的内存就会被自动释放
  • Redis 使用引用计数技术实现了对象共享机制，一定场景下，可以通过让多个数据库键共享同一个对象来节约内存
  • Redis 对象带有访问时间记录，可以用来计算数据库键的空转时间，在服务器启用 maxmemory 的情况下，空转时长较大的键可能被优先删除

对象结构

Redis 每个对象都是由一个 redisObject 结构表示，如下：

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct redisObject {
    // 对象类型
    unsigned type:4;
    // 编码
    unsigned encoding:4;
    // 记录最后一次被命令访问的时间
    unsigned lru:LRU_BITS;
    // 引用计数
    int refcount;
    // 指向底层实现的数据结构指针
    void *ptr;
} robj;

对象类型 type

对象的类型主要有如下常量值，分别对应不同对象类型 字符串对象、列表对象、集合对象 、有序集合对象 、哈希对象

1
2
3
4
5
6
7
8
9
10
// 字符串对象
#define OBJ_STRING 0
// 列表对象
#define OBJ_LIST   1
// 集合对象
#define OBJ_SET    2
// 有序集合对象
#define OBJ_ZSET   3
// 哈希对象
#define OBJ_HASH   4

作为 Redis 键值对 来说，键总是 字符串对象，而值是 各种对象，比如 常说的 列表键，实际就是 列表键对象，键为字符串对象，值是 列表对象

Redis 中命令 TYPE 可以查看数据的对象类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
[wettper@web-lovers redis-src]$ src/redis-cli 
// 字符串对象
127.0.0.1:6379> SET foo1 wettper
OK
127.0.0.1:6379> TYPE foo1
string
// 列表对象
127.0.0.1:6379> RPUSH foo2 1 2 3 4 5
(integer) 10
127.0.0.1:6379> TYPE foo2
list
// 哈希对象
127.0.0.1:6379> HMSET foo3 name wettper descript blogtext
OK
127.0.0.1:6379> TYPE foo3
hash
// 集合对象
127.0.0.1:6379> SADD foo4 a b c d e f
(integer) 6
127.0.0.1:6379> TYPE foo4
set
// 有序集合对象
127.0.0.1:6379> ZADD foo5 9.3 redis 1.1 mongo 3.2 mysql
(integer) 3
127.0.0.1:6379> TYPE foo5
zset

编码类型 encoding

对象的 ptr 指针指向对象的底层实现，就是 我们之前 提到的那些 数据结构，而 区分哪些 数据结构 的属性就是 encoding，encoding 有如下常量值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 简单动态字符串
#define OBJ_ENCODING_RAW        0
// long 类型整数
#define OBJ_ENCODING_INT        1
// 字典
#define OBJ_ENCODING_HT         2
// 已经废弃
#define OBJ_ENCODING_ZIPMAP     3
// 双端链表
#define OBJ_ENCODING_LINKEDLIST 4
// 压缩列表
#define OBJ_ENCODING_ZIPLIST    5
// 整数集合
#define OBJ_ENCODING_INTSET     6
// 跳跃表
#define OBJ_ENCODING_SKIPLIST   7
// embstr 编码的简单动态字符串
#define OBJ_ENCODING_EMBSTR     8
// 由双端链表和压缩列表构成的快速列表
#define OBJ_ENCODING_QUICKLIST  9

Redis 的每一种对象类型可以对应不同的编码方式，这就极大地提升了 Redis 的灵活性和效率，可以根据不同的使用场景，来选择合适的编码方式，五种对象类型对应的底层编码方式如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
+------------------------------------------------+
+ 对象类型           编码方式
+------------------------------------------------+
+ OBJ_STRING        OBJ_ENCODING_RAW
+                   OBJ_ENCODING_INT
+                   OBJ_ENCODING_EMBSTR
+------------------------------------------------+
+ OBJ_LIST          OBJ_ENCODING_LINKEDLIST
+                   OBJ_ENCODING_ZIPLIST
+                   OBJ_ENCODING_QUICKLIST
+------------------------------------------------+
+ OBJ_SET           OBJ_ENCODING_INTSET
+                   OBJ_ENCODING_HT
+------------------------------------------------+
+ OBJ_ZSET          OBJ_ENCODING_ZIPLIST
+                   OBJ_ENCODING_SKIPLIST
+------------------------------------------------+
+ OBJ_HASH          OBJ_ENCODING_ZIPLIST
+                   OBJ_ENCODING_HT
+------------------------------------------------+

LRU 访问

lru表示该对象最后一次被访问的时间，其占用 24 个bit位；保存该值的目的是为了计算该对象的空转时长，便于后续根据空转时长来决定是否释放该键，回收内存，通过 命令 OBJECT IDLETIME 查看对象的 空转时间（当前时间 - lru 时间）

1
2
3
4
5
6
7
8
9
10
[wettper@web-lovers redis-src]$ src/redis-cli 
127.0.0.1:6379> set foo1 wettper
OK
// 。。。。停留一会
127.0.0.1:6379> OBJECT IDLETIME foo1
(integer) 14
127.0.0.1:6379> get foo1
"wettper"
127.0.0.1:6379> OBJECT IDLETIME foo1
(integer) 2

我们可以看到设置完 foo1 键值对以后停留了一下，lru 值为 14，然后 get 访问后，lru 值立即缩短了，不过 OBJECT IDLETIME 这个命令不会修改 lru 的值，否则 我们怎么调试 ^-^

当然 lru 的设计并不是仅仅用来查看的，如果 服务器打开了 maxmemory 选项，在一定情况下 会 启动 lru 算法进行淘汰：

  • volatile-lru 根据LRU算法删除设置了超时属性（expire）的键，直到腾出足够空间为止；如果没有可删除的键对象，回退到noeviction策略。
  • allkeys-lru 根据LRU算法删除键，不管数据有没有设置超时属性，直到腾出足够空间为止
引用计数 refcount

实际 C 是不具备内存回收功能的，所以 Redis 在自己的对象系统中构建了一个引用计数的实现的回收机制，通过这一机制，程序可以通过跟踪对象的引用计数信息，在适当的时候自动释放对象并内存回收

对象的引用计数信息的变化规律如下：

  • 在创建一个对象的时候，引用计数的值会初始化为 1
  • 当对象被一个新程序使用时，它的引用计数值会增加 1
  • 当对象不再被一个程序使用时，它的引用计数值会减去 1
  • 当对象的引用计数值为 0 的时候，对象占用的内存会被释放

获取键值的 refcount 属性值也可以通过命令进行

1
2
3
4
5
[wettper@web-lovers redis-src]$ src/redis-cli 
127.0.0.1:6379> set foo1 wettper
OK
127.0.0.1:6379> OBJECT REFCOUNT foo1
(integer) 1

对象共享

除了 回收机制 功能外，对象的 引用计数 还带有 对象共享功能。Redis 默认会建立 0 ~ 9999 ( 通过 server.h: line 92 的常量 OBJ_SHARED_INTEGERS 控制 ) 每个数的对象，也就是说 Redis 在初始化的时候已经把这 10000个 数字对象建立了，只要后续使用到的 这个范围内的数字都会 直接引用这些对象，我们可以通过 refcount 属性来查看一下使用 对象共享功能情况，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
127.0.0.1:6379> set foo1 hello
OK
127.0.0.1:6379> set foo2 hello
OK
127.0.0.1:6379> OBJECT REFCOUNT foo1
(integer) 1
127.0.0.1:6379> OBJECT REFCOUNT foo2
(integer) 1
127.0.0.1:6379> set foo3 101
OK
127.0.0.1:6379> OBJECT REFCOUNT foo3
(integer) 2147483647
127.0.0.1:6379> set foo4 10001
OK
127.0.0.1:6379> OBJECT REFCOUNT foo4
(integer) 1

我们可以看到

  • foo1 和 foo2 的键值都为 hello 字符串，但是 引用计数都是 1
  • 而设置 foo3 键值为 101 这个数字 ，但是 引用计数设置为了 INT_MAX(2147483647) 值
  • 反观设置了 foo4 键值大于默认的 10000，引用计数为 1，没有使用 共享对象

当然，并不只是 字符串对象 才能使用这些 共享对象，那些在数据结构中嵌套了字符串对象都会用到（ 双向链表、哈希、有序集合 等）

那么为什么共享对象只是使用了 数字字符串呢？ 因为 服务器考虑将一个 对象设置为键 的值对象时，需要先检查 给定共享对象 跟 想要创建的对象 是否完全相同，只有在 共享对象 和 目标对象 完全相同的时候，程序才会使用 共享对象，所以 共享对象 保存的值越复杂，那么这个 对比过程 CPU 消耗率就越高

  • 数字字符串的对比验证复杂度为 O(1)
  • 字符串对比验证复杂度为 O(n)
  • 列表对象或者哈希对象的验证复杂度为 O(n2)*

所以，尽管共享对象更为节约内存，但是受 CPU 运算的限制，Redis 只包含整数值字符串的共享对象

源码解析

由于有些方法里的代码量比较大，我们这里按照 典型的代码片段进行解析，同志们可以根据文章提示的代码位置 和 代码里面的关键词 在源码中搜素，可能数据结构一些元素 看不太懂什么意思，没关系，先混个脸熟，后面看完回头再看过来就明白了

由于 对象 object 的 API 大多数都跟 各个数据类型 有关，我们后续在 各个数据类型模块会进行 附带讲解

此次我们主要讲解以下三个交互指令的源码

  • object refcount 返回对象的引用计数
  • object encoding 返回对象中存放的数据的编码方式
  • object idletime 返回对象的空转时长
  • object freq 返回对象的访问频率，这个地方相关的主要是利用 LFU 原理获取频率值后进行排序，获取热点 key
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/* object.c: line 1016 */
void objectCommand(client *c) {
    robj *o;
    // 打印 OBJECT help 命令内容
    if (!strcasecmp(c->argv[1]->ptr,"help") && c->argc == 2) {
        // 因为有的时候不太清楚输出信息的多少大小，所以需要一个链表集合先对输出信息进行保存
        void *blenp = addDeferredMultiBulkLength(c);
        // 初始化长度
        int blen = 0;
        // 添加 各种 命令help 信息的输出，同时增加链表元素数量值
        blen++; addReplyStatus(c,
        "OBJECT <subcommand> key. Subcommands:");
        blen++; addReplyStatus(c,
        "refcount -- Return the number of references of the value associated with the specified key.");
        blen++; addReplyStatus(c,
        "encoding -- Return the kind of internal representation used in order to store the value associated with a key.");
        blen++; addReplyStatus(c,
        "idletime -- Return the idle time of the key, that is the approximated number of seconds elapsed since the last access to the key.");
        blen++; addReplyStatus(c,
        "freq -- Return the access frequency index of the key. The returned integer is proportional to the logarithm of the recent access frequency of the key.");
        // 回复结果集合传递给 客户端
        setDeferredMultiBulkLength(c,blenp,blen);
    } else if (!strcasecmp(c->argv[1]->ptr,"refcount") && c->argc == 3) {
        // 返回 key 所指的对象的引用计数，以 long 类型返回
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        addReplyLongLong(c,o->refcount);
    } else if (!strcasecmp(c->argv[1]->ptr,"encoding") && c->argc == 3) {
        // 返回 key 所指的对象中存放的数据的编码方式，以 string 类型返回
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        addReplyBulkCString(c,strEncoding(o->encoding));
    } else if (!strcasecmp(c->argv[1]->ptr,"idletime") && c->argc == 3) {
        // 返回 key 所指的对象的空转时长，不过这里会想对 maxmeory 策略进行判断，返回 long 类型
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
            addReplyError(c,"An LFU maxmemory policy is selected, idle time not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
            return;
        }
        addReplyLongLong(c,estimateObjectIdleTime(o)/1000);
    } else if (!strcasecmp(c->argv[1]->ptr,"freq") && c->argc == 3) {
        // 返回 key 所指 LFU 访问频率，不过这里会想对 策略进行判断 必须为 allkeys-lfu或者volatile-lfu，返回 long 类型
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        if (!(server.maxmemory_policy & MAXMEMORY_FLAG_LFU)) {
            addReplyError(c,"An LFU maxmemory policy is not selected, access frequency not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
            return;
        }
        addReplyLongLong(c,LFUDecrAndReturn(o));
    } else {
        addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try OBJECT help",
            (char *)c->argv[1]->ptr);
    }
}

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-source-object.html
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

wettper <br /><br /> 现 离职状态 程序猿 <br /><br /> 叫醒我的不止阳光，还有梦想！<br /><br /> 喵喵、念念、健身、吉他！