渐进式解析 Redis 源码 - 字符串类型 t_string

阅读量

字符串类型 在 Redis 中属于最常见也是最简单的数据类型，底层实现主要为 sds 简单动态字符串结构

字符串类型 底层实现为 简单动态字符串数据结构，所以是 二进制安全的，意味着可以存储任何格式数据，不过长度要求不能高于 512MB…

字符串对象结构

对象的基础知识可以查看上一篇文章（对象 object），字符串对象 的编码为 OBJ_ENCODING_RAW、OBJ_ENCODING_INT、OBJ_ENCODING_EMBSTR，那么 字符串对象 结构如下

1
2
3
4
5
6
7
8
9
typedef struct redisObject {
    // 对象类型为 OBJ_STRING
    unsigned type:4;
    // 编码为 OBJ_ENCODING_RAW、OBJ_ENCODING_INT、OBJ_ENCODING_EMBSTR
    unsigned encoding:4;
    ......
    // 指向底层实现的数据结构指针
    void *ptr;
} robj;

  • 如果字符串对象保存的是 整数值，并且这个整数值可以用 long类型表示，那么 字符串对象会将整数值保存在字符串对象结构的 ptr 属性里（ void 转为了 long 类型），并将 encoding 设置为 OBJ_ENCODING_INT
  • 如果字符串对象保存的是 字符串，并且这个字符串长度 大于 44 字节（OBJ_ENCODING_EMBSTR_SIZE_LIMIT 常量控制），那么字符串对象使用 简单动态字符串结构 表示，并将 encoding 设置为 OBJ_ENCODING_RAW
  • 如果字符串对象保存的是 字符串，并且这个字符串长度 小于等于 44 字节（OBJ_ENCODING_EMBSTR_SIZE_LIMIT 常量控制），那么字符串对象使用 简单动态字符串结构 表示，并将 encoding 设置为 OBJ_ENCODING_EMBSTR

而为什么同样是 字符串类型值，但是有的使用 raw 有的使用 embstr 呢？

embstr 编码为专门用于保存 短小字符串的优化编码方式，跟 raw 一样都是基于 sds 简单动态字符串数据结构；在构建 字符串对象的时候，raw 会调用两次内存分配函数来分别创建 redisObject 结构 和 sds 结构，而 embstr 则是只调用一次内存分配函数 申请了一块连续的内存，依次包含 redisObject 和 sds 两个结构，实际产生功能效果是一样的；所以

  • embstr 编码 比 raw 编码 在申请内存空间的时候 次数 -1，同样道理，释放内存的时候也只需要 调用一次内存释放函数
  • embstr 编码的内存空间是 连续的，操作的时候更加便利

但是呢，embstr 只适合长度较小的字符串；如果长度过长，申请大内存段比较费力，因此，Redis 规定了小于规定字节才采用 embstr编码

下面我们就 Redis 字符串类型 一些典型的 API 进行解析~~~

源码解析

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

字符串类型的 命令对应处理文件为 t_string.c

查询功能

查询命令 get/getset 对应的 函数为 getCommand() 和 getsetCommand()，在查询数据方面主逻辑函数是 getGenericCommand()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* t_string.c: line 157 */
int getGenericCommand(client *c) {
    robj *o;
    // 查找元素
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
        return C_OK;
    // 再次限制如果查找到的不是 字符串类型，抛出异常，这里也是为了 client 响应的 适配性
    if (o->type != OBJ_STRING) {
        addReply(c,shared.wrongtypeerr);
        return C_ERR;
    } else {
        // 将信息存储输出列表
        addReplyBulk(c,o);
        return C_OK;
    }
}

上面逻辑中查找元素部分使用了 lookupKeyReadOrReply() 函数，这个函数的主逻辑函数为 lookupKey()

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
/* db.c: line 53 */
robj *lookupKey(redisDb *db, robj *key, int flags) {
    // 字典 dictEntry 节点 查找，根据 key 找到字典数据，具体 字典以及 dictFind 函数 的详解请详见 http://www.web-lovers.com/redis-source-dict.html
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        // 获取 dictEntry 节点值，也就是 元素值对象
        robj *val = dictGetVal(de);
        /* Update the access time for the ageing algorithm.
         * Don't do it if we have a saving child, as this will trigger
         * a copy on write madness. */
        // 更新 LRU/LFU 值，不过 如果存在如下条件之一就不会更新该对象的 LRU/LFU 属性：
        // 1、当前正在执行 rdb 文件写入
        // 2、当前正在执行 aof 操作
        // 3、当前操作的 flag=LOOKUP_NOTOUCH
        if (server.rdb_child_pid == -1 &&
            server.aof_child_pid == -1 &&
            !(flags & LOOKUP_NOTOUCH))
        {
            // 更新 LFU 值，即 更新 对象的频率，LFU 频率值主要用来获取 热词
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
                updateLFU(val);
            } else {
            // 更新 LRU 值
                val->lru = LRU_CLOCK();
            }
        }
        return val;
    } else {
        return NULL;
    }
}

mget 命令的逻辑跟 get 命令的逻辑基本类似，不过输出模式不太一样而已，需要多行输出

更新/添加 功能

更新/添加 功能的命令主要有 set、setex、setnx 等，主要功能函数为 setGenericCommand()，不过 setCommand() 函数在处理也有一定的逻辑，我们一块进行解读……

注意 setCommand 的 过期时间expire 主要是这样的形式 SET foo1 hello EX 18600

命令格式：SET key value [EX seconds] [PX milliseconds] [NX|XX]

  • EX second 设置键的过期时间为 second 秒；SET key value EX second 效果等同于 SETEX key second value
  • PX millisecond 设置键的过期时间为 millisecond 毫秒；SET key value PX millisecond 效果等同于 PSETEX key millisecond value
  • NX 只在键不存在时，才对键进行设置操作；SET key value NX 效果等同于 SETNX key value
  • XX 只在键已经存在时，才对键进行设置操作
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
/* t_string.c: line 96 */
void setCommand(client *c) {
    int j;
    robj *expire = NULL;
    int unit = UNIT_SECONDS;
    // 用于标记ex/px和nx/xx命令参数
    int flags = OBJ_SET_NO_FLAGS;
    // 从命令串的第四个参数开始，查看其是否设定了ex/px和nx/xx
    for (j = 3; j < c->argc; j++) {
        char *a = c->argv[j]->ptr;
        robj *next = (j == c->argc-1) ? NULL : c->argv[j+1];
        if ((a[0] == 'n' || a[0] == 'N') &&
            (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
            !(flags & OBJ_SET_XX))
        {
            flags |= OBJ_SET_NX;
        } else if ((a[0] == 'x' || a[0] == 'X') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                   !(flags & OBJ_SET_NX))
        {
            flags |= OBJ_SET_XX;
        } else if ((a[0] == 'e' || a[0] == 'E') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                   !(flags & OBJ_SET_PX) && next)
        {
            flags |= OBJ_SET_EX;
            unit = UNIT_SECONDS;
            expire = next;
            j++;
        } else if ((a[0] == 'p' || a[0] == 'P') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
                   !(flags & OBJ_SET_EX) && next)
        {
            flags |= OBJ_SET_PX;
            unit = UNIT_MILLISECONDS;
            expire = next;
            j++;
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
    }
    // 判断value是否可以编码成整数，如果能则编码；反之不做处理
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    // 调用底层函数进行键值对设定
    setGenericCommand(c,flags,c->argv[1],c->argv[2],expire,unit,NULL,NULL);
}
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
/* t_string.c: line 67 */
void setGenericCommand(client *c, int flags, robj *key, robj *val, robj *expire, int unit, robj *ok_reply, robj *abort_reply) {
    long long milliseconds = 0;
    // 如果设定了过期时间
    if (expire) {
        // 验证 expire对象中的具体时间值
        if (getLongLongFromObjectOrReply(c, expire, &milliseconds, NULL) != C_OK)
            return;
        // 验证时间
        if (milliseconds <= 0) {
            addReplyErrorFormat(c,"invalid expire time in %s",c->cmd->name);
            return;
        }
        // 设置时间单位
        if (unit == UNIT_SECONDS) milliseconds *= 1000;
    }
    // 验证 NX 和 XX，NX 键不存在，XX 键存在
    if ((flags & OBJ_SET_NX && lookupKeyWrite(c->db,key) != NULL) ||
        (flags & OBJ_SET_XX && lookupKeyWrite(c->db,key) == NULL))
    {
        addReply(c, abort_reply ? abort_reply : shared.nullbulk);
        return;
    }
    // 关联到 db
    setKey(c->db,key,val);
    // 数据保存记录增加，dirty 用来存储上次保存前所有数据变动的长度，用于以后判断在执行命令的过程中是否有了db中数据的变化，用得到的结果来判断要不要执行aof操作
    server.dirty++;
    // 设置过期时间
    if (expire) setExpire(c,c->db,key,mstime()+milliseconds);
    // 发送事件通知
    notifyKeyspaceEvent(NOTIFY_STRING,"set",key,c->db->id);
    // 发送定期事件通知
    if (expire) notifyKeyspaceEvent(NOTIFY_GENERIC,
        "expire",key,c->db->id);
    addReply(c, ok_reply ? ok_reply : shared.ok);
}

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-source-string.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 /> 喵喵、念念、健身、吉他！