Redis高频数据类型深度解析

# 1. 存东西：SET 格子名 内容
SET user:1:name "张三"
SET user:1:age 25

# 2. 取东西：GET 格子名
GET user:1:name  # 拿到 "张三"

# 3. 给数字加1（原子操作，不会错）
INCR user:1:age   # 年龄变成 26
INCRBY user:1:age 5  # 一次性加5，变成31

# 4. 批量存/取，减少跑腿
MSET user:2:name "李四" user:2:age 28
MGET user:1:name user:2:name  # 一次拿到两个人的名字

// SDS 本质是一个 char*，但它的"左上角信息"藏在内容的前面
typedef char *sds;

// 5种不同大小的便利贴，根据内容长度选
// 1. 小便利贴：内容<256字节，用1字节记长度
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len;        // 已经写了多少字
    uint8_t alloc;      // 这个便利贴总共多大
    unsigned char flags; // 标记这是哪种便利贴
    char buf[];         // 实际写内容的地方
};

// 2. 中便利贴：内容<65536字节，用2字节记长度
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len;
    uint16_t alloc;
    unsigned char flags;
    char buf[];
};

// 还有更大的 sdshdr32、sdshdr64，用来存更长的内容

// 源码：src/sds.c
sds sdsMakeRoomFor(sds s, size_t addlen) {
    // ... 省略无关代码
    newlen = len + addlen; // 我需要的新长度

    // 空间预分配策略：
    if (newlen < 1024*1024) 
        newlen *= 2; // 小于1MB的，多留一倍空
    else
        newlen += 1024*1024; // 大于1MB的，最多留1MB空
    // ... 重新分配内存
}

// 源码：src/sds.c
sds sdstrim(sds s, const char *cset) {
    // ... 找到新的长度
    s[len] = '\0';
    sdssetlen(s, len); // 只改了"已经写了多少字"，便利贴大小不变
    return s;
}

# 1. 给小抽屉放东西：HSET 大盒子名 抽屉名 内容
HSET user:1 name "张三" age 25 email "zhangsan@example.com"

# 2. 拿单个抽屉的东西：HGET
HGET user:1 name  # 拿到 "张三"

# 3. 拿所有抽屉的东西：HGETALL
HGETALL user:1  # 拿到所有抽屉的名字和内容

# 4. 给抽屉里的数字加1：HINCRBY
HINCRBY user:1 age 1  # 年龄变成26

// 纸条的结构：
// [总大小] [最后一个抽屉的位置] [抽屉数量] [抽屉1] [抽屉2] ... [结束标记]
// 每个抽屉的结构：
// [前一个抽屉的大小] [编码] [内容]

// 字典结构
typedef struct dict {
    dictht ht[2];    // 两个目录！一个旧的，一个新的
    long rehashidx;   // 搬家进度，-1就是没在搬家
    // ... 其他
} dict;

// 哈希表结构
typedef struct dictht {
    dictEntry **table; // 目录数组
    unsigned long size; // 目录大小
    unsigned long used; // 已经放了多少抽屉
} dictht;

// 每次你操作一个抽屉，我就搬一个旧目录的抽屉到新目录
int dictRehash(dict *d, int n) {
    while (n-- && 旧目录还有东西) {
        // 搬一个抽屉
        // ...
        d->rehashidx++; // 搬家进度+1
    }
    // 搬完了，旧目录扔了，新目录变成旧的
}

# 1. 加人：左边加（队头）用 LPUSH，右边加（队尾）用 RPUSH
LPUSH queue:task "task1"  # 队头加任务1
RPUSH queue:task "task2"  # 队尾加任务2，现在队伍是 [task1, task2]

# 2. 拉人：左边拉用 LPOP，右边拉用 RPOP
LPOP queue:task  # 拉走队头的task1
RPOP queue:task  # 拉走队尾的task2

# 3. 阻塞拉人：队里没人的时候，我等你10秒，有了就拿
BRPOP queue:task 10

// 快速列表结构
typedef struct quicklist {
    quicklistNode *head; // 第一组
    quicklistNode *tail; // 最后一组
    unsigned long count; // 总共有多少人
    int fill : 16;       // 每组最多多大（默认8KB）
    unsigned int compress : 16; // 压缩深度，中间的组没人动，我就打包起来省地方
} quicklist;

// 组的结构
typedef struct quicklistNode {
    quicklistNode *prev; // 前一组
    quicklistNode *next; // 后一组
    unsigned char *zl;   // 组内的ziplist，把组里的人挤在一起
    unsigned int count : 16; // 组里有多少人
    unsigned int encoding : 2; // 有没有打包压缩
} quicklistNode;

# 1. 放球：SADD，重复的自动忽略
SADD tag:1 "Java" "Redis" "面试"
SADD tag:1 "Java"  # 再放Java，没用，袋子里还是只有一个

# 2. 看有没有这个球：SISMEMBER
SISMEMBER tag:1 "Redis"  # 有，返回1
SISMEMBER tag:1 "MySQL"  # 没有，返回0

# 3. 集合运算
SADD tag:2 "Java" "MySQL"
SINTER tag:1 tag:2  # 交集：两个标签都有的，返回["Java"]
SUNION tag:1 tag:2  # 并集：所有标签，返回["Java","Redis","面试","MySQL"]

typedef struct intset {
    uint32_t encoding; // 编码：用16位整数，还是32位，还是64位
    uint32_t length;   // 有多少个球
    int8_t contents[]; // 按从小到大排好的数字
} intset;

// 源码：src/intset.c
static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
    // 1. 换个大的编码，比如从16位换成32位
    // 2. 重新买个更大的纸条
    // 3. 把原来的数字都抄到新纸条上，每个都转成新的编码
    // 4. 把新数字加进去
}

# 1. 加玩家：ZADD 排行榜名 分数 玩家名
ZADD rank:game 100 "张三" 200 "李四" 150 "王五"

# 2. 看玩家排第几：ZRANK是升序（分数低的排前面），ZREVRANK是降序（分数高的排前面）
ZRANK rank:game "张三"   # 张三分数最低，排第0（也就是第1名，从0开始数）
ZREVRANK rank:game "李四" # 李四分数最高，排第0

# 3. 拿前N名：ZREVRANGE 从高到低拿，WITHSCORES 把分数也拿出来
ZREVRANGE rank:game 0 1 WITHSCORES  # 前2名：["李四",200,"王五",150]

# 4. 给玩家加分数：ZINCRBY
ZINCRBY rank:game 50 "张三"  # 张三加50分，变成150

typedef struct zset {
    dict *dict;    // 字典：玩家名 -> 分数，O(1) 找你多少分
    zskiplist *zsl; // 跳表：按分数排序，O(log n) 找排名、找前N名
} zset;

// 跳表节点
typedef struct zskiplistNode {
    sds ele;           // 玩家名
    double score;      // 分数
    struct zskiplistNode *backward; // 后退指针，从后往前翻
    struct zskiplistLevel {
        struct zskiplistNode *forward; // 前进指针，下一个节点
        unsigned long span;             // 跨度，两个节点之间隔了多少人，用来算排名
    } level[]; // 层级数组，每个节点的层级是随机的
} zskiplistNode;

// 源码：src/t_zset.c
int zslRandomLevel(void) {
    int level = 1;
    // 每次有1/2的概率加一层，1/4的概率加两层，1/8的概率加三层...
    while ((random() & 0xFFFF) < (0.25 * 0xFFFF))
        level += 1;
    return level < 32 ? level : 32; // 最多32层
}