1
// C 原生字符串
2
char *str = "hello";  // 长度需 O(n) 遍历，不防溢出
3

4
// SDS 结构（Redis 5.0 sdshdr16 为例）
5
struct __attribute__((__packed__)) sdshdr16 {
6
    uint16_t len;        // 已使用长度：O(1) 获取
7
    uint16_t alloc;      // 总分配容量（不含 header 和 \0）
8
    unsigned char flags; // 类型标识：sdshdr5/8/16/32/64
9
    char buf[];          // 实际数据，以 \0 结尾
10
};

1
// SDS 扩容逻辑（简化）
2
sds sdsMakeRoomFor(sds s, size_t addlen) {
3
    size_t len = sdslen(s);
4
    size_t newlen = len + addlen;
5

6
    if (newlen < SDS_MAX_PREALLOC)  // 1MB
7
        newlen *= 2;                // 翻倍分配
8
    else
9
        newlen += SDS_MAX_PREALLOC; // 线性增长 1MB
10

11
    // 分配新空间...
12
}

1
// Redis 跳表节点
2
typedef struct zskiplistNode {
3
    sds ele;                           // 成员对象
4
    double score;                      // 分值
5
    struct zskiplistNode *backward;    // 后退指针（Level 0）
6
    struct zskiplistLevel {
7
        struct zskiplistNode *forward; // 前进指针
8
        unsigned long span;            // 跨度（用于排名计算）
9
    } level[];                         // 层（柔性数组）
10
} zskiplistNode;
11

12
// 跳表
13
typedef struct zskiplist {
14
    struct zskiplistNode *header, *tail;
15
    unsigned long length;   // 节点数量
16
    int level;              // 最大层数
17
} zskiplist;

1
typedef struct intset {
2
    uint32_t encoding;  // 编码方式：INT16/INT32/INT64
3
    uint32_t length;    // 元素数量
4
    int8_t contents[];  // 实际数据（按编码决定元素大小）
5
} intset;

1
// intset 升级示例：从 INT16 升级到 INT32
2
// 升级前：[1, 2, 3] 每个占 2 字节，共 6 字节
3
// 插入 65535（超出 INT16 范围）
4
// 升级后：[1, 2, 3, 65535] 每个占 4 字节，共 16 字节
5

6
intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
7
    uint8_t valenc = _intsetValueEncoding(value);
8
    uint32_t pos;
9

10
    if (valenc > intrev32ifbe(is->encoding)) {
11
        // 需要升级：重新分配内存，从后向前搬运元素
12
        return intsetUpgradeAndAdd(is, value);
13
    }
14
    // ... 正常插入（二分查找 + 移位）
15
}

1
// 哈希表
2
typedef struct dictht {
3
    dictEntry **table;      // 哈希桶数组
4
    unsigned long size;     // 哈希表大小（2 的幂）
5
    unsigned long sizemask; // 哈希表大小掩码（size - 1）
6
    unsigned long used;     // 已有节点数量
7
} dictht;
8

9
// 字典
10
typedef struct dict {
11
    dictType *type;     // 类型特定函数
12
    void *privdata;     // 私有数据
13
    dictht ht[2];       // 两个哈希表（rehash 时使用）
14
    long rehashidx;     // rehash 进度（-1 表示未进行）
15
    int16_t pauserehash;// 暂停 rehash 的安全标记
16
} dict;

1
// 渐进式 rehash 核心逻辑（简化）
2
static void _dictRehashStep(dict *d) {
3
    // 每次迁移一个桶
4
    dictRehash(d, 1);
5
}
6

7
int dictRehash(dict *d, int n) {
8
    int empty_visits = n * 10; // 最多访问 10n 个空桶
9
    while (n-- && d->ht[0].used != 0) {
10
        dictEntry *de, *nextde;
11
        // 跳过空桶
12
        while (d->ht[0].table[d->rehashidx] == NULL) {
13
            d->rehashidx++;
14
            if (--empty_visits == 0) return 1;
15
        }
16
        de = d->ht[0].table[d->rehashidx];
17
        // 迁移该桶所有节点到 ht[1]
18
        while (de) {
19
            uint64_t h;
20
            nextde = de->next;
21
            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
22
            de->next = d->ht[1].table[h];
23
            d->ht[1].table[h] = de;
24
            d->ht[0].used--;
25
            d->ht[1].used++;
26
            de = nextde;
27
        }
28
        d->ht[0].table[d->rehashidx] = NULL;
29
        d->rehashidx++;
30
    }
31
    // 检查是否迁移完毕
32
    if (d->ht[0].used == 0) {
33
        zfree(d->ht[0].table);
34
        d->ht[0] = d->ht[1];
35
        _dictReset(d->ht + 1);
36
        d->rehashidx = -1;
37
        return 0; // rehash 完成
38
    }
39
    return 1; // rehash 进行中
40
}

1
typedef struct quicklistNode {
2
    struct quicklistNode *prev;   // 前驱节点
3
    struct quicklistNode *next;   // 后继节点
4
    unsigned char *entry;         // 指向 listpack 的指针
5
    size_t count;                 // 本节点元素数
6
    unsigned int container : 2;  // 节点类型，2 表示 listpack
7
    unsigned int encoding : 2;   // 编码，1 表示 LZF 压缩
8
    // ...
9
} quicklistNode;

1
typedef struct redisObject {
2
    unsigned type:4;        // 类型：STRING/LIST/HASH/SET/ZSET
3
    unsigned encoding:4;    // 编码：int/embstr/raw/listpack/quicklist/...
4
    unsigned lru:24;        // LRU 时间戳或 LFU 计数器
5
    int refcount;           // 引用计数
6
    void *ptr;              // 指向底层数据结构的指针
7
} robj;

1
// server.c 初始化
2
void createSharedObjects(void) {
3
    for (int j = 0; j < OBJ_SHARED_INTEGERS; j++) {
4
        shared.integers[j] = makeObjectShared(
5
            createObject(OBJ_STRING, sdsfromlonglong(j))
6
        );
7
        shared.integers[j]->refcount = OBJ_SHARED_REFCOUNT; // 无限引用
8
    }
9
}

1
# Hash 编码自动转换示例
2
HSET user:1 name "Tom"          # listpack 编码（field 数 ≤ 128）
3
# ... 继续添加 129 个 field ...
4
HSET user:1 field129 "value"    # 自动转换为 hashtable 编码
5
OBJECT ENCODING user:1          # "hashtable"

1
# RDB 自动触发配置（redis.conf，Redis 7 默认）
2
save 3600 1    # 3600 秒内有至少 1 次修改
3
save 300 100   # 300 秒内有至少 100 次修改
4
save 60 10000  # 60 秒内有至少 10000 次修改

1
# 重写前 AOF（6 条命令）
2
SET counter 1
3
INCR counter
4
INCR counter
5
INCR counter
6
DEL temp_key
7
RPUSH mylist a b c
8

9
# 重写后 AOF（2 条命令）
10
SET counter 4
11
RPUSH mylist a b c

1
// AOF 重写流程（简化）
2
int rewriteAppendOnlyFileBackground(void) {
3
    pid_t childpid;
4

5
    if ((childpid = redisFork()) == 0) {
6
        // 子进程：遍历数据库，生成最简命令
7
        char tmpfile[256];
8
        snprintf(tmpfile, sizeof(tmpfile), "temp-rewriteaof-bg-%d.aof", getpid());
9
        if (rewriteAppendOnlyFile(tmpfile) == C_OK) {
10
            exitFromChild(0);
11
        } else {
12
            exitFromChild(1);
13
        }
14
    } else {
15
        // 父进程：记录子进程 PID，继续服务
16
        server.aof_child_pid = childpid;
17
        // 同时将重写期间的新命令写入 AOF 重写缓冲区
18
        server.aof_rewrite_buf = sdsempty();
19
    }
20
}

1
// 事件循环主函数
2
void aeMain(aeEventLoop *eventLoop) {
3
    eventLoop->stop = 0;
4
    while (!eventLoop->stop) {
5
        if (eventLoop->beforesleep != NULL)
6
            eventLoop->beforesleep(eventLoop);  // 循环前钩子
7
        aeProcessEvents(eventLoop, AE_ALL_EVENTS |
8
                        AE_CALL_AFTER_SLEEP);   // 处理所有事件
9
    }
10
}
11

12
// aeProcessEvents 核心逻辑（简化）
13
int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
14
    // 1. 查找最近的时间事件，计算阻塞时间
15
    if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
16
        shortest = aeSearchNearestTimer(eventLoop);
17

18
    // 2. 调用 epoll_wait 等待文件事件
19
    numevents = aeApiPoll(eventLoop, &tvp);
20

21
    // 3. 处理文件事件（优先）
22
    for (j = 0; j < numevents; j++) {
23
        fe = &eventLoop->events[eventLoop->fired[j].fd];
24
        if (fe->mask & mask & AE_READABLE)
25
            fe->rfileProc(eventLoop, fd, fe->clientData, mask);
26
        if (fe->mask & mask & AE_WRITABLE)
27
            fe->wfileProc(eventLoop, fd, fe->clientData, mask);
28
    }
29

30
    // 4. 处理时间事件
31
    if (flags & AE_TIME_EVENTS)
32
        processTimeEvents(eventLoop);
33
}

1
# redis.conf 多线程配置
2
io-threads 4               # I/O 线程数（建议 ≤ CPU 核心数）
3
io-threads-do-reads yes     # 读操作也使用多线程

1
// 惰性删除：访问时检查是否过期
2
robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
3
    robj *val;
4
    if (expireIfNeeded(db, key) == 0) {
5
        // 键已过期，返回 NULL
6
        return NULL;
7
    }
8
    val = lookupKey(db, key, flags);
9
    return val;
10
}
11

12
// 定期删除：周期性随机抽样删除过期键
13
void activeExpireCycle(int type) {
14
    // 每次循环抽样 20 个键
15
    // 如果过期键占比 > 25%，继续抽样
16
    // 每轮最多执行 25ms（自适应频率）
17
    for (int j = 0; j < dbs_per_call; j++) {
18
        int expired = 0;
19
        do {
20
            num = dictGetSomeKeys(db->expires, samples, ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP);
21
            for (i = 0; i < num; i++) {
22
                if (keyIsExpired(db, samples[i])) {
23
                    deleteKey(db, samples[i]);
24
                    expired++;
25
                }
26
            }
27
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP / 4);
28
    }
29
}

1
// LFU 计数器更新（简化）
2
uint8_t lfuIncr(uint8_t counter) {
3
    if (counter < 255) {
4
        double r = (double)rand() / RAND_MAX;
5
        double baseval = counter - LFU_INIT_VAL;
6
        if (baseval < 0) baseval = 0;
7
        // 概率递增：计数器越大，递增概率越低
8
        double p = 1.0 / (baseval * lfu_log_factor + 1);
9
        if (r < p) counter++;
10
    }
11
    return counter;
12
}
13

14
// LFU 衰减：每 lfu_decay_time 分钟计数器减 1
15
unsigned long LFUDecrAndReturn(robj *o) {
16
    unsigned long ldt = o->lru >> 8;  // 高 16 位：衰减时间
17
    unsigned long counter = o->lru & 255; // 低 8 位：计数器
18
    unsigned long num_periods = server.unixtime - ldt;
19
    if (num_periods > lfu_decay_time) {
20
        counter = (num_periods / lfu_decay_time) > counter ? 0 :
21
                  counter - (num_periods / lfu_decay_time);
22
    }
23
    return counter;
24
}

1
# 检测 bigkey
2
redis-cli --bigkeys -i 0.1
3

4
# 示例输出
5
-------- summary -------
6
Biggest string found so far: 'user:session:xxx' with 5.2 MB
7
Biggest   list found so far: 'queue:tasks' with 128456 entries
8
Biggest    set found so far: 'tag:popular' with 89234 members
9
Biggest   hash found so far: 'user:profile:123' with 523 fields
10
Biggest   zset found so far: 'rank:daily' with 234567 members

1
# 异步删除 bigkey
2
UNLINK rank:daily    # 非阻塞删除，后台线程回收内存
3

4
# 拆分 bigkey 示例
5
# 原：HSET user:123 field1 v1 field2 v2 ... field500 v500
6
# 拆：HSET user:123:1 field1 v1 field2 v2
7
#     HSET user:123:2 field3 v3 field4 v4

1
# 查看 fork 耗时
2
redis-cli INFO stats | grep latest_fork_usec
3
# latest_fork_usec:82300   # 单位微秒，82ms
4

5
# 延迟监控（需开启 latency monitor）
6
redis-cli CONFIG SET latency-monitor-threshold 100
7
redis-cli LATENCY HISTORY fork

1
redis-cli SET mykey "hello"
2
redis-cli GET mykey
3
# "hello"
4

5
redis-cli TYPE mykey
6
# string
7

8
redis-cli OBJECT ENCODING mykey
9
# embstr

1
redis-cli LPUSH mylist a b c d e
2
redis-cli LLEN mylist
3
# (integer) 5
4

5
redis-cli OBJECT ENCODING mylist
6
# listpack

1
redis-cli HSET myhash field1 value1 field2 value2 field3 value3
2
redis-cli HGETALL myhash
3
redis-cli OBJECT ENCODING myhash
4
# listpack

1
redis-cli ZADD myzset 1 "one" 2 "two" 3 "three" 4 "four" 5 "five"
2
redis-cli ZRANGE myzset 0 -1 WITHSCORES
3
redis-cli OBJECT ENCODING myzset
4
# listpack

1
redis-cli MEMORY USAGE mykey
2
# (integer) 64
3

4
redis-cli MEMORY USAGE mylist
5
# (integer) 72
6

7
redis-cli MEMORY USAGE myhash
8
# (integer) 104
9

10
redis-cli MEMORY USAGE myzset
11
# (integer) 96

1
redis-cli CONFIG GET save
2
# 1) "save"
3
# 2) "3600 1 300 100 60 10000"
4

5
redis-cli BGSAVE
6
# Background saving started
7

8
redis-cli LASTSAVE
9
# (integer) 1778209989

1
redis-cli INFO memory | head -8

1
# Memory
2
used_memory:1357784
3
used_memory_human:1.29M
4
used_memory_rss:8388608
5
used_memory_rss_human:8.00M
6
used_memory_peak:1357784
7
used_memory_peak_human:1.29M
8
used_memory_peak_perc:100.01%
9
used_memory_overhead:949432

1
# 一次性查看关键指标
2
redis-cli INFO memory | grep -E "used_memory:|used_memory_rss:|mem_fragmentation_ratio:"
3
redis-cli INFO stats | grep -E "latest_fork_usec|expired_keys|evicted_keys"
4
redis-cli INFO clients | grep connected_clients