《Redis系列第二篇、String具体使用(均附有测试命令)与String底层数据结构介绍｜CSDN创作打卡》

一篇文章彻底学会Redis的String使用

目录

String具体使用

测试前清空当前库

SET与GET

MSET与MGET

DEL

EXPIRE与TTL/PTTL

redis数据存储结构

redis string类型转换

string编码转换源码分析

---

String具体使用

SET      key  value                            //设置字符串键值对
MSET     key  value [key value ...]            //批量设置字符串键值对
SETNX    key  value                            //设置字符串键值对，当key存在就不做处理直接返回0，否则跟set命令一样
GET      key                                   //获取一个字符串键值
MGET     key  [key ...]                        //批量获取字符串键值
DEL      key  [key ...]                        //删除一个键
EXPIRE   key  seconds                          //设置一个键的过期时间(秒)
TTL      key                                   //获取一个键的过期时间(秒)
PTTL     key                                   //获取一个键的过期时间(毫秒)

测试前清空当前库

flushall

SET与GET

set obj test
get obj
strlen obj

MSET与MGET

mset mobj1 "a1" mobj2 "a2" mobj3 "a3"
mget mobj1 mobj2 mobj3 

DEL

del mobj1 mobj2 mobj3

EXPIRE与TTL/PTTL

set obj test
expire obj 200
get obj
ttl obj
pttl obj

 redis数据存储结构

redis的内部整体的存储结构就是一个大的hashmap，内部实现是数组实现hash，冲突通过挂链去实现，然后每个dictEntry就是一个key/value对象。dictEntry的key指向set key value命令中的key对应的对象，dictEntry的v指向set key value命令中的value对应的对象。

dictEntry 内部包含数据存储的key和v变量，同时包含一个dictEntry的next指针连接落入同一个hash桶的对象。dictEntry当中的key和v的指针指向的是redisObject。

/*
 * 哈希表节点
 */
typedef struct dictEntry {
    
    // 键
    void *key;

    // 值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
    } v;

    // 指向下个哈希表节点，形成链表
    struct dictEntry *next;

} dictEntry;

redisObject是redis server存储最原子数据的数据结构，其中的void *ptr会指向真正的存储数据结构，我们set key value中的key和value其实由ptr指向真正保存的位置。

typedef struct redisObject {

    // 类型
    unsigned type:4;

    // 编码
    unsigned encoding:4;

    // 对象最后一次被访问的时间
    unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */

    // 引用计数
    int refcount;

    // 指向实际值的指针
    void *ptr;

} robj;

redis string类型转换

我们可能以为redis在内部存储string都是用sds的数据结构实现的，其实在整个redis的数据存储过程中为了提高性能，内部做了很多优化。整体选择顺序应该是：

• 整数，存储字符串长度小于21且能够转化为整数的字符串。

• EmbeddedString，存储字符串长度小于39的字符串（REDIS_ENCODING_EMBSTR_SIZE_LIMIT）根据版本不同，也可能是44。

• SDS，剩余情况使用sds进行存储。

embstr和sds的区别在于内存的申请和回收

• embstr的创建只需分配一次内存，而raw为两次（一次为sds分配对象，另一次为redisObject分配对象，embstr省去了第一次）。相对地，释放内存的次数也由两次变为一次。

• embstr的redisObject和sds放在一起，更好地利用缓存带来的优势

• 缺点：redis并未提供任何修改embstr的方式，即embstr是只读的形式。对embstr的修改实际上是先转换为raw再进行修改。

string编码转换源码分析

通过redis 内部的命令映射表我们找到set对应的处理函数为setCommand，相当于这个是处理set命令的入口函数，关注下tryObjectEncoding，内部对其实对Object进行转换。

/* SET key value [NX] [XX] [EX <seconds>] [PX <milliseconds>] */
void setCommand(redisClient *c) {
    int j;
    robj *expire = NULL;
    int unit = UNIT_SECONDS;
    int flags = REDIS_SET_NO_FLAGS;

    // 设置选项参数
    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 |= REDIS_SET_NX;
        } else if ((a[0] == 'x' || a[0] == 'X') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0') {
            flags |= REDIS_SET_XX;
        } else if ((a[0] == 'e' || a[0] == 'E') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' && next) {
            unit = UNIT_SECONDS;
            expire = next;
            j++;
        } else if ((a[0] == 'p' || a[0] == 'P') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' && next) {
            unit = UNIT_MILLISECONDS;
            expire = next;
            j++;
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
    }

    // 尝试对值对象进行编码
    c->argv[2] = tryObjectEncoding(c->argv[2]);

    setGenericCommand(c,flags,c->argv[1],c->argv[2],expire,unit,NULL,NULL);
}

整个尝试编码转换的逻辑过程通过代码的注释应该是比较清楚了，过程如下：

• 只对长度小于或等于 21 字节，并且可以被解释为整数的字符串进行编码，使用整数存储
• 尝试将 RAW 编码的字符串编码为 EMBSTR 编码，使用EMBSTR 编码
• 这个对象没办法进行编码，尝试从 SDS 中移除所有空余空间，使用SDS编码

/* Try to encode a string object in order to save space */
// 尝试对字符串对象进行编码，以节约内存。
robj *tryObjectEncoding(robj *o) {
    long value;

    sds s = o->ptr;
    size_t len;
    redisAssertWithInfo(NULL,o,o->type == REDIS_STRING);

    // 只在字符串的编码为 RAW 或者 EMBSTR 时尝试进行编码
    if (!sdsEncodedObject(o)) return o;

     // 不对共享对象进行编码
     if (o->refcount > 1) return o;

    // 对字符串进行检查
    // 只对长度小于或等于 21 字节，并且可以被解释为整数的字符串进行编码
    len = sdslen(s);
    if (len <= 21 && string2l(s,len,&value)) {
        if (server.maxmemory == 0 &&
            value >= 0 &&
            value < REDIS_SHARED_INTEGERS)
        {
            decrRefCount(o);
            incrRefCount(shared.integers[value]);
            return shared.integers[value];
        } else {
            if (o->encoding == REDIS_ENCODING_RAW) sdsfree(o->ptr);
            o->encoding = REDIS_ENCODING_INT;
            o->ptr = (void*) value;
            return o;
        }
    }

    // 尝试将 RAW 编码的字符串编码为 EMBSTR 编码
    if (len <= REDIS_ENCODING_EMBSTR_SIZE_LIMIT) {
        robj *emb;

        if (o->encoding == REDIS_ENCODING_EMBSTR) return o;
        emb = createEmbeddedStringObject(s,sdslen(s));
        decrRefCount(o);
        return emb;
    }

    // 这个对象没办法进行编码，尝试从 SDS 中移除所有空余空间
    if (o->encoding == REDIS_ENCODING_RAW &&
        sdsavail(s) > len/10)
    {
        o->ptr = sdsRemoveFreeSpace(o->ptr);
    }

    /* Return the original object. */
    return o;
}