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
┌──────────┬───────────┬───────────┬─────────┬─────────┬─────────┐
2
│ zlbytes  │  zltail   │  zllen    │ entry1  │ entry2  │  zlend  │
3
│ 4 bytes  │  4 bytes  │  2 bytes  │  变长   │  变长   │ 1 byte  │
4
└──────────┴───────────┴───────────┴─────────┴─────────┴─────────┘
5
                              │
6
                              ▼
7
                    ┌─────────────────────┐
8
                    │  prevlen  │  encoding │  data   │
9
                    │  1/5 bytes│  变长     │  变长   │
10
                    └─────────────────────┘

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 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
┌──────────────────────────────────────────────────┐
2
│  redisObject (16 bytes)  │  sdshdr8 + buf + \0   │
3
│  type|encoding|lru|ref   │  len|alloc|flags|data  │
4
└──────────────────────────────────────────────────┘
5
  ← 一次 malloc 分配，一次 free 释放 →

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）
2
save 900 1      # 900秒内有至少1次修改
3
save 300 10     # 300秒内有至少10次修改
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
repl-timeout 60          # 复制超时（秒）
3
repl-diskless-sync no    # 是否无盘复制（直接通过网络发送 RDB）
4
client-output-buffer-limit replica 256mb 64mb 60  # 从节点输出缓冲区限制

1
// 增量复制核心逻辑
2
int masterTryPartialResynchronization(client *c, long long psync_offset) {
3
    long long psync_len;
4

5
    // 检查主节点 runid 是否匹配
6
    if (strcasecmp(c->argv[1]->ptr, server.replid)) {
7
        goto need_full_sync;  // runid 不匹配，需全量
8
    }
9

10
    // 检查偏移量是否在 backlog 范围内
11
    if (psync_offset < server.repl_backlog_off ||
12
        psync_offset > (server.repl_backlog_off + server.repl_backlog_histlen))
13
    {
14
        goto need_full_sync;  // 偏移量已过期，需全量
15
    }
16

17
    // 增量复制：发送 backlog 中从 psync_offset 开始的数据
18
    psync_len = server.repl_backlog_off + server.repl_backlog_histlen - psync_offset;
19
    // ... 发送 psync_len 字节数据 ...
20
    return C_OK;
21
}

1
# 哨兵选举流程（Raft 协议简化版）
2
1. 哨兵 A 发现主节点主观下线（SDOWN）
3
2. 哨兵 A 询问其他哨兵：是否同意主节点下线？
4
3. 超过 quorum 数量的哨兵同意 → 客观下线（ODOWN）
5
4. 哨兵之间选举 Leader（Raft 协议）
6
5. Leader 哨兵执行故障转移：
7
   a. 选择新主节点（优先级 > 复制偏移量 > runid 最小）
8
   b. 对新主节点执行 SLAVEOF NO ONE
9
   c. 通知其他从节点复制新主节点
10
   d. 更新 sentinel 配置

1
# 集群键路由算法
2
def slot(key):
3
    # 哈希标签：{user}:1 和 {user}:2 映射到同一槽
4
    if key contains "{...}":
5
        key = extract_hash_tag(key)
6
    return CRC16(key) % 16384
7

8
# 示例
9
CRC16("mykey") % 16384 = 12867   # 槽 12867
10
CRC16("{user}:1") % 16384 = 5474 # 槽 5474
11
CRC16("{user}:2") % 16384 = 5474 # 同一槽，支持多键操作

1
// ae.c — 根据平台选择实现
2
#ifdef HAVE_EVPORT
3
#include "ae_evport.c"   // Solaris event ports
4
#else
5
    #ifdef HAVE_EPOLL
6
    #include "ae_epoll.c"    // Linux epoll 最常用
7
    #else
8
        #ifdef HAVE_KQUEUE
9
        #include "ae_kqueue.c"  // macOS/FreeBSD kqueue
10
        #else
11
        #include "ae_select.c"  // POSIX select（兜底）
12
        #endif
13
    #endif
14
#endif

1
// ae_epoll.c — epoll 封装（简化）
2
typedef struct aeApiState {
3
    int epfd;                    // epoll 实例
4
    struct epoll_event *events;  // 事件数组
5
} aeApiState;
6

7
static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
8
    aeApiState *state = eventLoop->apidata;
9
    int retval, numevents = 0;
10

11
    // 等待事件就绪，tvp 为超时时间
12
    retval = epoll_wait(state->epfd, state->events, eventLoop->setsize,
13
                        tvp ? (tvp->tv_sec * 1000 + tvp->tv_usec / 1000) : -1);
14

15
    if (retval > 0) {
16
        numevents = retval;
17
        for (int j = 0; j < numevents; j++) {
18
            int mask = 0;
19
            struct epoll_event *e = state->events + j;
20
            if (e->events & EPOLLIN)  mask |= AE_READABLE;
21
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
22
            eventLoop->fired[j].fd = e->data.fd;
23
            eventLoop->fired[j].mask = mask;
24
        }
25
    }
26
    return numevents;
27
}

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
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