Redis 核心源码解析：从设计哲学到企业级应用实践

一、Redis 的核心设计哲学

Redis 的成功源于其 「用内存换时间」 的核心理念，围绕以下三个核心原则构建：

极简主义：单线程模型避免锁竞争，代码保持高度内聚。
性能至上：所有数据常驻内存，网络层采用事件驱动模型。
可扩展性：模块化设计，通过插件机制支持新功能。

二、源码目录结构解析

从 Redis 7.0 源码看核心模块：

redis/src
├── ae.c              # 事件循环（核心）
├── anet.c            # 网络抽象层
├── dict.c            # 哈希表实现
├── object.c          # 数据类型封装
├── rdb.c             # RDB持久化
├── aof.c             # AOF持久化
├── server.c          # 服务端主逻辑
├── networking.c      # 客户端连接处理
└── modules           # 模块化扩展

三、核心模块源码深度解析

1. 事件驱动模型：单线程为何能扛10万QPS？

Redis 采用 Reactor 模式 实现高并发，核心代码在 ae.c：

// 事件循环主逻辑（ae.c）
void aeMain(aeEventLoop *eventLoop) {eventLoop->stop = 0;while (!eventLoop->stop) {aeProcessEvents(eventLoop, AE_ALL_EVENTS | AE_CALL_BEFORE_SLEEP);}
}// 处理事件（精简版）
int aeProcessEvents(aeEventLoop *eventLoop, int flags) {// 1. 获取最近要到期的时间事件shortest = aeSearchNearestTimer(eventLoop);// 2. 等待文件事件（epoll_wait/kevent等）numevents = aeApiPoll(eventLoop, tvp);// 3. 处理文件事件（网络请求）for (j = 0; j < numevents; j++) {fe = &eventLoop->events[eventLoop->fired[j].fd];fe->rfileProc(...); // 处理读事件fe->wfileProc(...); // 处理写事件}// 4. 处理时间事件（如过期键清理）processed += processTimeEvents(eventLoop);
}

技术要点：

基于 epoll/kqueue 实现多路复用
单线程顺序处理事件，避免锁开销
时间事件与文件事件协同调度

2. 内存管理：如何实现高效数据存储？

核心结构 redisObject（object.c）：

typedef struct redisObject {unsigned type:4;        // 数据类型（string/hash等）unsigned encoding:4;    // 编码方式（优化存储）unsigned lru:24;        // LRU时间戳int refcount;           // 引用计数void *ptr;              // 数据指针
} robj;// 字符串类型示例（sds.h）
struct sdshdr {int len;        // 已用长度int free;       // 剩余空间char buf[];     // 柔性数组
};

编码优化策略：

String：int编码（存储整数时） vs embstr编码（短字符串） vs raw编码
Hash：ziplist（元素少时） vs hashtable
Sorted Set：skiplist + dict 实现 O(logN) 查询

3. 持久化机制：RDB与AOF如何协同工作？

RDB 快照生成（rdb.c）：

// 异步生成RDB（fork子进程）
int rdbSaveBackground(char *filename, rdbSaveInfo *rsi) {if ((childpid = fork()) == 0) {// 子进程执行实际保存retval = rdbSave(filename,rsi);exitFromChild((retval == C_OK) ? 0 : 1);} else {// 父进程记录状态server.rdb_child_pid = childpid;}
}

AOF 重写（aof.c）：

// 重写AOF文件（同样fork子进程）
int rewriteAppendOnlyFileBackground(void) {if (aofCreatePipes() != C_OK) return C_ERR;if ((childpid = fork()) == 0) {// 子进程重写if (rewriteAppendOnlyFile(tmpfile) == C_OK) {exitFromChild(0);}}
}

持久化流程对比：

	RDB	AOF
原理	内存快照	操作日志追加
优点	恢复快、文件小	数据丢失风险低
缺点	数据可能丢失	文件大、恢复慢

4. 数据结构：Sorted Set 如何实现高效排序？

核心代码 t_zset.c：

// 跳跃表节点定义
typedef struct zskiplistNode {sds ele;                            // 成员double score;                       // 分数struct zskiplistNode *backward;     // 后退指针struct zskiplistLevel {struct zskiplistNode *forward;  // 前进指针unsigned long span;             // 跨度} level[];                          // 层级数组
} zskiplistNode;// 插入节点核心逻辑
zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {// 1. 随机生成节点层级（幂次定律）level = zslRandomLevel();// 2. 查找插入位置for (i = zsl->level-1; i >= 0; i--) {while (x->level[i].forward && (x->level[i].forward->score < score || ... )) {x = x->level[i].forward;}update[i] = x;}// 3. 创建新节点并调整指针x = zslCreateNode(level,score,ele);for (i = 0; i < level; i++) {x->level[i].forward = update[i]->level[i].forward;update[i]->level[i].forward = x;}
}

性能优势：

跳跃表平均 O(logN) 时间复杂度
结合哈希表实现 O(1) 成员存在性检查

四、企业级应用源码适配案例

案例1：分布式锁实现（Redlock算法）

// 加锁命令（基于SET命令）
SET lock_key $unique_id NX PX 30000// 解锁Lua脚本（保证原子性）
if redis.call("get",KEYS[1]) == ARGV[1] thenreturn redis.call("del",KEYS[1])
elsereturn 0
end

源码支撑：

SET 命令在 t_string.c 实现
Lua 脚本执行逻辑在 scripting.c

案例2：热点数据缓存穿透防御

// 布隆过滤器实现（redisbloom模块）
BF.ADD hot_items:filter "item_123"
BF.EXISTS hot_items:filter "item_456"

源码扩展：

模块化开发接口在 redismodule.h
底层使用 dablooms 库实现

五、Redis 核心架构图

+-------------------+
|      Client       |
+-------------------+|| 发送命令v
+-------------------+
|    Event Loop     | <--- 文件事件（网络I/O）
| (ae.c/ae_epoll.c) | 
|                   | <--- 时间事件（过期键清理）
+-------------------+|| 命令路由v
+-------------------+
|   Command Table   | ---> 命令处理器（get/set等）
|  (server.c/cmd)   |
+-------------------+|| 数据操作v
+-------------------+
|    Data Store     | ---> 字符串/hash/有序集合等
| (object.c/t_*.c)  |
+-------------------+|| 持久化触发v
+-------------------+
|  Persistence      | ---> RDB（rdb.c） / AOF（aof.c）
+-------------------+