
参考资料:
Redis - Real-time data for agents & apps
Redis 学习总结
1. Redis 基础概述
Redis:Remote Dictionary Server,C语言开发,内存型键值数据库 核心特性:
- 内存为主,支持持久化落盘;
- 二进制安全的key;
- 多数据结构,不只是简单k-v;
- 支持网络访问,C/S架构;
- 支持原子命令、Lua、事务、分布式锁;
- 支持主从、哨兵、集群实现高可用和分片。
定位区分:
MySQL:磁盘存储、关系模型、复杂查询、事务强一致;
Redis:内存、NoSQL、高吞吐低延迟,多用于缓存、中间件能力。
2. Redis IO模型
前置说明:
IO模型讨论的是【应用程序和内核之间处理IO的方式】,以网络IO(TCP读写)为例,一次IO分为两个阶段:
阶段1:等待内核准备好数据(数据从网卡到内核缓冲区)
阶段2:把内核缓冲区的数据拷贝到用户进程缓冲区
四种基础IO模型:3种同步IO + 1种异步IO
1. 阻塞IO(Blocking I/O)
原理:
调用recvfrom这类系统调用时,如果内核还没准备好数据,线程直接阻塞休眠,一直等到数据就绪并且拷贝完成之后,函数才返回。
流程:
进程发起IO调用 → 内核没数据,进程阻塞 → 内核收到网络数据、准备好缓冲区 → 内核把数据拷贝到用户空间 → 调用返回,进程继续执行

优点:编码简单
缺点:一个线程只能处理一个连接;连接多了就要开大量线程,上下文切换、内存开销巨大
用途:简单小程序,不会用于Redis、Nginx这类高并发中间件
2. 非阻塞IO(Non-Blocking I/O)
原理:
设置socket为非阻塞。调用IO系统调用时,如果内核数据没准备好,不会阻塞线程,直接返回错误码( EWOULDBLOCK );应用程序需要不断轮询,反复调用API询问内核数据好了没有。
流程:
进程循环发起IO调用 → 没数据立刻返回失败 → 进程不停轮询重试 → 数据就绪,拷贝完成返回数据

优点:线程不会卡死在单个IO等待上
缺点:轮询非常消耗CPU,大部分调用都是无效空跑;一般不单独使用
用途:很少单独用,常作为IO多路复用的配套属性
3. IO多路复用(I/O Multiplexing,Redis、Nginx用这个)
同步VS异步
IO多路复用属于同步 IO 。
同步IO:数据拷贝是用户线程自己做(阻塞、非阻塞、多路复用都是同步)
异步IO:数据拷贝由内核自动完成,做完通知你
原理
内核提供select/poll/epoll,进程把一堆socket注册到内核,然后调用多路复用函数阻塞等待;
内核监听所有注册socket,只要任意一个socket就绪(可读/可写),就唤醒进程,进程再去对就绪的socket执行读写操作。
流程
把多个socket交给epoll监听 → 调用epoll_wait阻塞等待事件 → 某个socket有数据到达,内核通知进程 → 进程自己调用recv把数据从内核缓冲区拷贝到用户缓冲区

三大实现
Select
文件描述符有上限,每次调用都要重新传全部fd,内核需要全量遍历
Poll
去掉fd上限,但是依然需要内核遍历所有fd
epoll(Linux)
事件驱动,就绪回调,O(1),Redis默认使用
epoll 有两种事件触发模式,Redis 默认使用LT水平触发

- LT 水平触发(Level Triggered,默认模式)
原理
只要 socket 的内核缓冲区**还有可读/可写数据**,epoll_wait 就会持续返回这个 fd,一直通知你。
-
只要缓冲区有数据 → 每次 epoll_wait 都上报事件
-
直到你把缓冲区数据全部读完为止,才不再通知
流程
-
网卡收到数据,内核读缓冲区有内容
-
epoll_wait 返回该 fd 可读事件
-
业务读一部分数据,**缓冲区还剩数据**
-
再次调用 epoll_wait,**仍然会再次返回这个fd**
优点
-
简单、容错高;就算一次没读完,下次还会提醒
-
不容易丢事件,代码好写
缺点
- 如果忘记读完缓冲区,会反复触发事件,造成epoll_wait频繁唤醒(惊群/频繁循环)
- ET 边缘触发(Edge Triggered)
原理
只有状态发生变化的一瞬间才触发一次:也就是只有当数据从【无】变成【有】的那一刻,通知一次。
缓冲区已有数据、后续新增数据才会触发;缓冲区里旧的剩余数据不会重复通知!
流程
-
网卡收到数据,缓冲区从空→有数据,触发一次可读事件
-
epoll_wait 返回fd
-
业务只读取一部分,缓冲区还有残留数据
-
缓冲区还有数据,但不会再通知了!除非再来新数据
硬性要求(ET写代码必须遵守)
ET模式下,收到事件之后,必须循环 read/recv,直到返回 EAGAIN / EWOULDBLOCK(没有数据了),一次性把缓冲区全部掏空,否则数据滞留缓冲区、再也收不到事件,造成数据丢失。
所以ET一般必须搭配非阻塞socket使用!
优点
- 通知次数少,减少epoll事件回调次数,性能理论更好
缺点
- 极易丢数据,编码要求严格,容错差
优缺点
优点:单线程管理上万连接,CPU利用率高,没有大量线程开销
缺点:需要两次系统调用(epoll_wait + recv);本质同步,读写拷贝动作仍然是应用线程执行
用途
Redis、Nginx、Tomcat(NIO)高并发服务首选
4. 异步IO AIO(Asynchronous I/O,异步IO)
原理:
进程发起IO请求之后立刻返回,不用等待;
数据等待 + 内核 → 用户空间拷贝两步全部交给内核完成,全部做完之后内核通过信号/回调通知应用程序。
流程:
进程提交异步IO任务给内核 → 进程继续做别的事情,不阻塞、不用轮询 → 内核等待数据、并且自动把数据拷贝到用户缓冲区 → 内核通知应用:IO完成,可以直接使用数据

优点:全程不阻塞应用线程,内核全权负责等待+拷贝
缺点:Linux原生AIO不完善,限制多;Windows IOCP成熟
用途:Windows高性能服务;Linux下Redis、Nginx默认不使用AIO
二、回到Redis线程&IO模型(结合上面的IO模型)
1. Redis主线程定位
Redis 核心:命令执行单线程串行 Redis 6.0+ 引入IO多线程:
- IO多线程只负责:网络IO阶段(读客户端请求、写响应数据回客户端),也就是epoll事件触发之后,读取socket、打包响应
- 不变的核心:命令解析、命令执行、数据结构读写、持久化、 Lua 脚本执行全部仍然是主线程串行执行,命令不会并发跑
- 为什么不把命令做多线程?Redis的数据结构没有锁,单线程简化并发控制,避免锁竞争。
2. Redis为什么选择 IO多路复用(epoll)
- 绝大多数操作是内存操作,本身极快,瓶颈不在计算,而在大量TCP连接管理;
- epoll让单一线程可以监听海量客户端连接;
- 规避阻塞IO多线程带来的线程切换、锁、内存开销。
3. 主线程阻塞风险(重点)
IO多路复用只是解决【等待IO】的并发问题,不能解决命令执行耗时阻塞的问题!
主线程串行执行命令,只要一条命令执行时间很长,整个主线程卡住,所有连接都无法处理。
- 高危慢命令:
keys、hgetall、smembers、zrange 0 -1、flushall/flushdb、超大Lua脚本、大集合全量遍历 - 渐进式替代(游标分片):
scan、hscan、sscan、zscan,分批拉取数据,单次执行很快,不阻塞主线程
4. 补充:Redis的后台线程(bio)
除主线程、6.0 IO线程外,Redis还有BIO后台线程组:
- 专门做一些耗时独立任务:关闭大文件、AOF刷盘等;
- BIO 线程不能执行 Redis 命令,只是独立后台任务,不要和 IO 多线程混淆
对比速记表
|-----------------------------|-------|-----------------|--------------------|------------------|
| IO模型 | 同步/异步 | 阻塞 | 特点 | Redis是否使用 |
| 阻塞 IO | 同步 | 是 | 一个线程一个连接,简单低效 | ❌ |
| 非阻塞 IO | 同步 | 否 | 需要循环轮询,耗CPU | ❌(仅作为epoll配套属性) |
| IO 多路复用 (epoll) | 同步 | 是(epoll_wait阻塞) | 单线程监听大量socket,事件驱动 | ✅ Redis核心 |
| AIO 异步 IO | 异步 | 否 | 内核全权等待+拷贝,完成回调 | ❌ Linux上Redis不使用 |
3. Key通用操作
通用命令
SET/GET/DEL/EXISTS/TYPE
EXPIRE key seconds # 设置过期秒
PEXPIRE key ms
TTL / PTTL # -1 永不过期,-2 key不存在/已过期
PERSIST # 移除过期时间
RENAME / RENAMENX
SCAN cursor [MATCH] [COUNT]
说明
-
`SET key value`:设置键值
-
`GET key`:获取 key 对应的值
-
`DEL key key ...`:删除一个或多个 key
-
`EXISTS key key ...`:判断 key 是否存在,返回存在的 key 数量
-
`TYPE key`:查看 key 对应的数据类型(string/list/hash/set/zset/stream 等)
-
`EXPIRE key seconds`:给 key 设置过期时间,单位:**秒**
-
`PEXPIRE key milliseconds`:给 key 设置过期时间,单位:**毫秒**
-
`TTL key`:查看剩余过期时间(单位秒)
-
`PTTL key`:查看剩余过期时间(单位毫秒)
-
返回 `-1`:key 存在,**没有设置过期时间,永不过期**
-
返回 `-2`:key 不存在(已经过期被删除 或者 本来就没有)
-
`PERSIST key`:移除 key 的过期时间,key 变回永久有效
-
`RENAME key newkey`:重命名 key;如果 newkey 已存在,**会直接覆盖**
-
`RENAMENX key newkey`:仅当 newkey 不存在时,才执行重命名,避免覆盖
-
`SCAN cursor MATCH pattern COUNT count`
-
游标迭代遍历库中所有 key,**非阻塞,分批遍历**,替代危险的 `keys *`
-
`cursor`:游标,第一次传 0;返回结果里的新游标作为下一次入参;返回 0 代表遍历结束
-
`MATCH`:匹配 key 的通配符(过滤是在返回结果阶段,不是服务端过滤)
-
`COUNT`:提示服务器单次期望返回多少元素,**不是精确数量限制,只是参考值**
补充重点:
-
`EXPIRE` 只能作用于 key,不是 value;过期是 key 层面的机制
-
`RENAME`:如果 key 带过期时间,重命名后过期时间会继承到新 key
-
SCAN 是迭代器,**不保证快照一致性**,遍历期间 key 新增 / 删除,可能漏或者重复读到
-
禁止生产直接 `keys`,大数据量阻塞主线程,优先 SCAN
4.Redis内存淘汰机制
配置前置:
maxmemory 10gb # 最大可用内存,不设置则使用全部系统内存,非常危险
maxmemory-policy xxx # 淘汰策略
maxmemory-samples 5 # LRU/LFU抽样数量,不是精确LRU,是近似实现
触发时机:
执行写命令(set、hset等),检测内存达到maxmemory上限,执行淘汰。
虚拟内存机制:
暂时把不经常访问的数据(冷数据)从内存交换到磁盘中,从而腾出宝贵的内存空间用于其它需要访问的数据(热数据)。

3种过期策略
定时过期
每个设置过期时间的key都需要创建一个定时器,到过期时间就会立即对key进行清除。
该策略需要去维护一个定时器。
惰性过期
只有当访问一个key时,才会判断该key是否已过期,过期则清除。该策略极端情况可能出现大量的过期key没有再次被访问,从而不会被清除,占用大量内存。
定期过期
每隔一定的时间,会扫描一定数量的数据库的expires字典中一定数量的key,并清除其中已过期的key。
Redis中同时使用了惰性过期和定期过期两种过期策略。
8种淘汰策略完整说明

noeviction(默认):不淘汰,写请求直接返回OOM错误,线上一般不用allkeys-lru:所有 key 中,淘汰最近最少使用 LRU (生产最常用)volatile-lru:只在设置了过期时间的key里,淘汰LRUallkeys-lfu:所有key,淘汰访问频次最低(LFU,Redis0+)volatile-lfu:只过期key,LFUallkeys-random:所有key随机删volatile-random:过期key随机删volatile-ttl:过期key里优先删剩余存活时间最短的
LRU 和 LFU 区别
- LRU:看时间recently------最近有没有访问,很久没访问优先删;
- LFU:看频次frequently------访问次数,冷门低频key优先删;适合长期热点稳定场景。
Redis的LRU不是精确LRU:采用抽样,节省内存,近似效果足够业务使用。
补充:hz参数
hz 10:控制Redis后台定时任务频率(过期检查、统计、关闭超时连接等),最高可到500,越高CPU消耗越大。
5. 数据类型 + 底层编码
基础5种

- String:
- 底层SDS(C语言的字符串是char\[\]实现的,而Redis使用SDS(simple dynamic string) 封装);

- 二进制安全,最大512M;
- 计数器、缓存JSON、SETNX锁
- 底层SDS(C语言的字符串是char\[\]实现的,而Redis使用SDS(simple dynamic string) 封装);
- List:
- 底层quicklist(ziplist压缩列表 + 双向链表);

- 头尾O(1);
- 消息队列、时间线
- 底层quicklist(ziplist压缩列表 + 双向链表);
- Set:
- 底层intset(全整数、数量少)/ hashtable;

- 无序去重;
- 交集并集、抽奖
- 底层intset(全整数、数量少)/ hashtable;
- Hash:底层ziplist / hashtable;field-value;对象存储、购物车
- ZSet:底层ziplist / skiplist跳表+dict;score排序;排行榜、延时任务

高级4种(基于基础结构封装)
- Bitmap:String实现,bit操作;签到、日活统计
- HyperLogLog:基数统计,有0.81%误差;UV统计,不存明细
- Geo:ZSet封装,经纬度;附近的人
- Stream(Redis5.0+):独立结构,消息队列,支持消费组、ACK、持久化消息
底层编码自动转换:
当元素变多、value变大,会从压缩结构(ziplist/intset)转成hashtable/skiplist,提高读写速度,牺牲内存。
6. Redis持久化机制
RDB 快照
机制
执行 fork() 创建子进程,子进程生成全量二进制快照文件;
依托写时复制 COW ( Copy-On-Write )
fork瞬间父子进程共享同一份内存页;父进程后续修改内存页时,才会拷贝该内存页给子进程,避免fork瞬间复制全部内存,减少开销
触发方式

save:同步阻塞,主线程直接生成RDB,大数据量会阻塞服务,线上禁止使用bgsave:后台异步,fork子进程做快照,主线程继续处理命令(日常自动持久化底层就是bgsave)- 配置自动save规则:
save 900 1这类配置,满足【时间+修改key数量】条件自动触发bgsave
优缺点
- 优点
- 二进制紧凑文件,体积小;宕机恢复速度很快,适合冷备份、异地备份
- 缺点
- 两次快照之间的写数据没有落地,故障时会丢失这段时间的数据
- fork子进程有短暂CPU、内存开销;内存越大,fork耗时越高
AOF 追加日志
机制
以协议文本形式记录每一条写命令,追加写入AOF文件末尾

appendfsync 刷盘策略(核心)
-
always:每执行一条写命令就调用fsync强制刷磁盘。数据最安全,几乎不丢数据;磁盘IO压力极大,性能很差everysec(默认推荐):后台线程每秒执行一次fsync刷盘。最坏情况最多丢失1秒数据,安全性和性能均衡no:不主动fsync,交给操作系统内核自行决定什么时候刷盘。性能最好,但丢失数据不可控,风险高
AOF重写 bgrewriteaof
-
- 背景:AOF持续追加,文件越来越大,大量冗余命令(多次对同一个key set,只保留最后一条即可)
- 原理:fork子进程,读取当前内存数据,生成精简的命令序列写入新AOF;后台执行,不阻塞主线程
- 重写过程中父进程新产生的命令,会同时追加到老AOF和重写缓冲区,保证数据不丢
RDB-AOF 混合持久化(Redis4.0+,生产推荐开启)
- 配置:
aof-use-rdb-preamble yes - 机制:执行AOF重写的时候,新AOF文件开头先写入 RDB 格式的全量快照,快照之后再追加增量的AOF写命令
- 优势:兼顾两者优点
- RDB部分:重启加载速度快
- AOF增量部分:降低丢失数据的风险
- 重启加载优先级:Redis 启动优先加载 AOF 文件(开启混合持久化,加载的这个AOF里面包含RDB头部)

补充要点
- AOF重写、bgsave都是fork子进程,会复用COW机制;
- 混合持久化≠同时独立开启RDB+AOF,是AOF文件内部融合RDB快照;
- 如果同时开启RDB+AOF,启动依旧优先读AOF;
- AOF文件损坏时,可以用
redis-check-aof修复;RDB用redis-check-rdb。
7. 事务、Lua、Pipeline、Pub/Sub【扩充事务完整机制】
7.1 Redis 事务 MULTI / EXEC / DISCARD / WATCH
Redis事务本质:
命令入队,一次性串行执行,不支持回滚 执行三阶段:
- MULTI:开启事务,客户端进入事务状态;
- 后续命令入队列,不立即执行,只返回QUEUED;
- EXEC:主线程按顺序一次性执行队列所有命令;DISCARD清空队列放弃事务。
两种错误行为
入队阶段语法错误 :比如命令写错、参数不对 → EXEC直接拒绝,整个事务全部不执行
运行时执行错误 (语法没问题,但类型不匹配):错误命令报错,其他正常命令继续执行,不会回滚
bash
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.
核心原因:Redis设计者认为,运行时错误属于业务逻辑错误,应该业务层处理,不需要数据库回滚机制,换取高性能。
WATCH 乐观锁
WATCH key:监控key,在EXEC之前,如果这个key被其他客户端修改,本次事务直接执行失败(返回nil)。
- 是乐观锁,无阻塞;
- UNWATCH 取消监控;EXEC执行后自动取消所有WATCH。
适用场景:简单多key原子操作;
短板:不支持回滚、不支持跨slot(集群模式)、不能加条件重试逻辑。
7.2 Lua脚本 EVAL / EVALSHA
将多条Redis命令写在Lua脚本,发送到Redis服务端原子执行 优势:
- 原子执行,网络往返只有一次;
- 可以写判断、循环逻辑;
- EVALSHA缓存脚本,减少脚本传输流量; 限制:
- 脚本不能死循环、不能长时间阻塞;
- Redis提供lua超时保护,超时后只能执行SCRIPT KILL / SHUTDOWN;
分布式锁释放,标准实现就是Lua脚本(判断value匹配再删除,防止误删别人锁)
7.3 Pipeline(管道)
批量打包多条命令一次性发给Redis,一次性接收返回
⚠️ Pipeline 不保证原子性!只是减少网络 RTT,和事务、Lua区分开。
7.4 Pub/Sub 发布订阅
PUBLISH / SUBSCRIBE / PSUBSCRIBE(模式订阅) 缺陷:消息不持久化、离线消费者丢失消息、无ACK,不适合可靠消息,适合通知类场景。
8. 高可用体系
主从复制
一个主节点(master)负责写,多个从节点(slave/replica)同步主节点数据,实现读写分离。
PSYNC 增量同步
早期是SYNC全量同步,每次断线重连都要传全部RDB,开销很大。PSYNC支持全量同步 + 增量同步:断线时间短、偏移量还在主节点复制积压缓冲区里,就只同步断线期间缺失的命令;缓冲区丢了或者新从节点第一次接入,执行全量同步(生成RDB传给从库,再同步后续增量命令)。
异步复制
主节点写完数据就直接返回客户端成功,不会等从节点同步完再返回。 ✅ 优点:写性能高; ⚠️ 风险:主节点宕机,还没同步到从库的数据会丢失,不保证强一致。
读写分离,无自动故障转移
写请求走主节点,读请求分发到从节点,分摊读压力。
流程

重点:没有自动故障转移能力。主节点挂了,系统不会自动选从节点上位,必须人工操作:手动选一个从节点晋升为主,还要修改业务代码/配置,指向新主地址。
哨兵 Sentinel
哨兵本质是独立运行的进程,基于主从复制做故障自动转移,不支持分片,整个集群只有1个主节点。
三大核心能力:监控、自动故障转移、通知客户端
监控
哨兵持续向主、从节点发送探测命令,感知节点存活状态;哨兵之间也互相监控(哨兵集群,防止哨兵单点故障)。
故障判定
主观下线 + 客观下线。单个哨兵觉得主节点不通是主观下线;多个哨兵协商投票达成一致,标记为主节点客观下线。
故障转移
哨兵集群投票选出一个从节点,把它升级为新主;剩余从节点修改配置,复制新主;最后通知客户端新主地址。
通知
通过发布订阅通知业务客户端、运维人员。
局限:单主架构,不能分片扩容。所有数据都在这一组主从里,数据量大、写QPS很高的时候,单个主节点会成为瓶颈。
流程

哨兵持续探测主从状态;主节点宕机后,哨兵集群投票选出新主,自动修改其他从库的复制目标,业务通过哨兵拿到新主地址。
Redis Cluster 集群(分片集群)
Redis Cluster = 分片 + 主从 + 自动故障转移,数据分散存到多个主节点上,解决单主写瓶颈。
每台主节点负责一部分哈希槽的数据,节点之间存储内容不一样,天然分片。
16384 哈希槽 slot , CRC16(key) % 16384
所有key先做CRC16哈希,对16384取模,落到0~16383共16384个槽;每个主节点负责一部分slot。key固定属于一个slot,slot固定归属一个主节点。
部署起步推荐 3 主 3 从
3个主节点分摊slot,每个主搭配一个从节点做备份;某个主宕机,哨兵逻辑会自动把它的从提升为主,保障高可用。
能力:分片扩容 + 故障转移
可以新增主节点,迁移slot,横向扩容存储和写性能;同时自带故障检测、自动主从切换。
使用限制:
MGET/MSET、Redis事务、Lua脚本,默认不支持跨 slot 的多个 key,命令直接报错;- 解决方案:Hash Tag
{tag}:key1、{tag}:key2,大括号里相同内容参与哈希,强制多个key落到同一个slot。
集群节点之间依靠 Gossip 协议 异步交换集群元信息:节点存活状态、故障信息、新节点加入、主从切换、slot分配信息。Gossip是异步散播,信息最终一致,不是实时强一致。
Gossip 4种消息详解
meet 消息
作用:邀请新节点加入集群。
流程:集群内已有节点向新节点发送meet;新节点接收后,认可对方,加入集群;之后双方周期性互相ping/pong,同步集群状态。
ping 消息
集群最频繁的消息。每个节点每秒挑选若干其他节点发送ping;携带自身和已知其他节点的状态。
两个目的:探测对方是否存活;交换集群元数据。
pong 消息
ping、meet的响应包,确认连通;消息里面携带自己的节点信息、slot信息、状态。
节点也可以主动广播pong,主动同步自己最新状态给整个集群。
fail 消息
当一个节点判定某个节点已经客观下线,向集群广播fail消息;其他节点收到后,更新本地记录,标记该节点下线,触发后续故障转移流程。
Redis Cluster集群
每台Redis节点上存储不同的内容。
- 16384 slot哈希槽,CRC16(key)%16384;
- 3主3从起步;
- 分片扩容+故障转移;
- 限制:跨slot多key事务/mget不支持,可用hash tag
{tag}key强制同槽
Redis Cluster集群通过Gossip协议进行通信,节点之前不断交换信息,交换的信息内容包括节点出现故障、新节点加入、主从节点变更信息、slot信息等等。
Gossip消息

常用的Gossip消息分为4种,分别是:ping、pong、meet、fail。
meet消息
通知新节点加入。
meet消息通信正常完成后,接收节点会加入到集群中并进行周期性的ping、pong消息交换。
ping消息
集群内交换最频繁的消息,集群内每个节点每秒向多个其他节点发送ping消息,用于检测节点是否在线和交换彼此状态信息。
pong消息
当接收到ping、meet消息时,作为响应消息回复给发送方确认消息正常通信。
pong消息内部封装了自身状态数据。节点也可以向集群内广播自身的pong消息来通知整个集群对自身状态进行更新。
fail消息
节点下线时,会向集群内广播一个fail消息,其他节点接收到fail消息之后把对应节点更新为下线状态。
9. 缓存
Cache-Aside(旁路缓存,最常用)
读:查缓存→命中返回;未命中查DB,回写缓存
写:更新DB → 删除缓存(不是更新缓存)

缓存三大问题

缓存穿透
场景:查询数据库本来就不存在的数据,Redis里也没有对应的key,请求直接穿透打到DB;恶意传非法参数也会大量打库。
解决方案:
- 布隆过滤器:提前把所有合法主键放入布隆过滤器,查询先过过滤器,不存在直接拦截;
- 缓存空值:查不到数据时,往Redis写入一个短期过期的空标记;
- 参数前置校验:校验ID、手机号等参数格式,非法参数直接拒绝。
缓存击穿
场景:热点 key 到期瞬间,大量并发请求同时进来,缓存失效,全部打到数据库。
解决方案:
- 互斥锁:缓存失效时,只放行一个请求去更新缓存,其他请求等待重试;
- 逻辑过期:key设置为永不过期,value里存逻辑过期时间,后台异步线程刷新缓存,请求不用等过期。
key 不设置 Redis 的 TTL ,把过期时间放到 value 内。
javascript
{
"data": "商品数据",
"expireTime": 1765432100 // 逻辑过期时间(时间戳)
}
请求发现逻辑时间过期后,先返回旧数据,再通过锁控制单独一个线程异步更新缓存,其他请求直接返回旧值,避免并发打数据库,适合允许短暂脏数据的热点场景。
缓存雪崩
场景:大批量缓存key同一时间集中过期,或者Redis整体宕机,大量流量瞬间压垮数据库。
解决方案:
- 过期时间增加随机偏移量,打散过期时间;
- Redis集群高可用(哨兵/Cluster),避免单点宕机;
- 接入限流、熔断、降级机制;
- 多级缓存架构:本地Caffeine二级缓存 + Redis。
数据一致性优化
- 方案:延迟双删(更新DB → 删除缓存 → 延迟一段时间再删一次缓存)
- 特点:只能做到最终一致性
- 注意:强一致性业务场景不适合使用缓存方案。
10. 分布式锁
单节点正确命令:SET lock:xxx uuid NX EX 30
NX:不存在才设置;EX自动过期;value存唯一标识;
释放:Lua脚本判断value等于自己标识再DEL,禁止直接DEL;
风险:主从异步复制丢锁;Redlock红锁(工程很少使用);
Redisson:封装锁、看门狗自动续期、可重入锁、公平锁;
适用边界:允许极小概率锁失效业务;资金强一致用ZK。
11. Redis 安全机制
线上Redis暴露公网非常危险,安全是运维重点
11.1 网络层面
-
绑定 IP bind:默认bind 127.0.0.1,只允许本机访问;不要 bind 0.0.0.0 直接暴露公网;需要外部访问指定内网IP。
bind 127.0.0.1 192.168.1.10
-
防火墙策略:只放行业务服务器IP访问6379,拒绝陌生IP;
-
端口修改:修改默认6379端口,降低扫描攻击概率(防扫描,不是真正安全)
11.2 密码认证 requirepass
requirepass MyRedis@Pass123
客户端连接后必须 AUTH ``密码,否则拒绝执行命令;
集群、哨兵节点都需要配置密码,主从同步也需要masterauth参数。
11.3 命令重命名(高危命令禁用/改名)
线上把危险命令改名或者禁用,防止误操作、黑客执行
bash
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command KEYS ""
rename-command CONFIG "my_config_cmd"
值为""代表直接禁用该命令。
高危清单:keys``、flushall、flushdb、config、shutdown
11.4 保护模式 protected-mode
protected-mode yes
默认开启:当没有设置密码、没有bind指定ip,Redis只允许本地访问,拒绝外部访问。公网环境一定要开启。
11.5 权限(Redis6+ ACL访问控制列表,细粒度权限,推荐)
ACL可以创建多个用户,限制:可以访问哪些key、允许执行哪些命令、是否可以读写 示例:
user appuser on >pass123 ~app:* +@read -@admin
含义:appuser用户,密码pass123,只能访问app:*开头key,只能读命令,禁止管理员命令; 适合多业务共用一套Redis,做权限隔离。
11.6 其他安全点
- 不要使用root用户启动redis进程;
- 关闭不必要的模块;
- 开启慢日志审计,监控异常高危命令;
- 定期备份RDB/AOF,防止勒索病毒;
- TLS加密:Redis6+支持tls加密传输,内网可选,跨公网强烈建议开启加密。
12. Redis 实现 Session 共享
背景
单体服务session存在服务器内存;集群多台服务时,请求落到不同机器,session丢失。
解决方案:把Session放到Redis,所有应用实例共享同一份session。
流程
- 用户登录成功,服务生成唯一sessionId;
- 把用户登录信息序列化存入Redis,key=sessionId,设置过期时间(如30分钟);
- 返回sessionId写入浏览器Cookie / 返回前端Token;
- 后续请求携带sessionId,服务从Redis读取用户信息;
- 退出登录:DEL sessionId;
- 续期:每次访问刷新EXPIRE,滑动过期。
优点
- 无状态,服务可以弹性扩缩容;
- 可以统一做登录校验、单点登录;
⚠️ 注意点:
- 设置合理过期时间,自动清理过期会话;
- session信息敏感,不要存明文密码;
- Redis要做持久化+高可用,避免大量用户同时掉线;
- Redis-session服务端保存状态,可以主动踢人下线;
- JWT无状态无法主动失效(除非维护黑名单)。
框架:SpringSession 默认就是把Session存入Redis实现共享。
13. Redis 监控指标、慢查询、日志、告警
13.1 info 命令(最核心监控,info all 查看全部)
info 分为多个section:server、clients、memory、persistence、stats、replication、cpu、cluster等
重点指标清单
memory 内存板块
used_memory:Redis分配的内存(数据+缓冲区)used_memory_rss:操作系统看到Redis进程占用内存(和used_memory差值大,大概率内存碎片高)mem_fragmentation_ratio = used_memory_rss / used_memory- 比值>1.5:内存碎片严重,需要重启或者bgrewriteaof
- 接近1:碎片正常
maxmemory:配置最大内存evicted_keys:被内存淘汰策略剔除的key数量(持续上涨代表内存不够,需要扩容或者优化key过期)expired_keys:过期删除的key
stats 统计板块
keyspace_hits:缓存命中次数keyspace_misses:缓存未命中次数
缓存命中率 = hits / (hits + misses) 理想:>90%;持续偏低说明缓存设计有问题(大量穿透、过期不合理)
total_commands_processed:总命令处理量rejected_connections:拒绝连接数(连接数打满)
clients 连接
connected_clients当前客户端连接数maxclients最大连接上限;接近上限会拒绝新连接
persistence 持久化
rdb_last_bgsave_status:上次RDB是否成功(ok/err,告警重点)aof_last_bgrewrite_status:AOF重写状态aof_current_size:AOF文件大小
replication 主从
master_link_status:up/down,主从连接状态,down代表同步断开
13.2 慢查询 slowlog
Redis慢查询:只统计命令执行时间,不包含网络往返时间 配置:
bash
slowlog-log-slower-than 10000 # 单位微秒,10000=10ms,超过这个时间记入慢日志
slowlog-max-len 128 # 慢日志队列最多存多少条
命令:
bash
SLOWLOG GET 10
SLOWLOG RESET
排查阻塞、大key、不合理命令的第一手段。
13.3 日志配置
bash
loglevel notice # debug/verbose/notice/warning;生产推荐notice
logfile /var/log/redis/redis.log
日志会记录:启动、RDB/AOF、主从断开、客户端异常、ACL登录失败等。
13.4 常用监控工具 & 告警项
监控工具:Prometheus + redis_exporter + Grafana
必须配置告警:
- Redis进程宕机;
- RDB/AOF持久化失败;
- 内存使用率接近maxmemory;
- 缓存命中率持续下降;
- 主从同步断开;
- 慢查询数量突增;
- 连接数打满、拒绝连接;
- 内存碎片率过高。
13.5 其他诊断命令
bash
redis-cli --bigkeys # 扫描大key
redis-cli --hotkeys # Redis4+ 扫描热key
MEMORY USAGE key # 查看单个key占用内存
14. 线上问题 & 性能优化

大key:value过大;拆分、不要hgetall,用hscan
说明:大key指单个key对应的value体积很大(比如超大String、成员极多的Hash/List/ZSet)。
危害:
- 读写耗时变长,阻塞Redis;
- 迁移key(集群扩容、槽迁移)时卡顿;
- 删除大key会产生大量内存释放,造成主线程阻塞。 优化方案:
- 拆分:把一个大Hash拆成多个小Hash;
- 禁止
HGETALL、LRANGE 0 -1一次性全拉; - 使用
HSCAN、ZSCAN、SSCAN迭代分批读取; - 删除大key不要直接DEL,分批删除。
热key:超高QPS访问同一个key;本地二级缓存、主从副本分流
说明:某个key访问量远高于其他key(比如首页爆款商品),流量打在同一个Redis节点,打满节点CPU。
危害:单节点CPU打满,其他节点空闲,流量倾斜,容易超时雪崩。 优化方案:
- 本地二级缓存(Caffeine、Guava Cache),应用内存缓存一份,减少Redis请求;
- 读写分离,读请求打到从节点副本分流;
- 热key副本:复制多份相同key散落到不同slot;
- 限流保护。
内存碎片:碎片率高;重启、AOF重写
说明:Redis分配、释放内存后,产生很多零散小块内存,无法复用,内存占用高于实际数据大小,碎片率=碎片内存/已分配内存。
碎片查看:INFO memory 看 mem_fragmentation_ratio,一般超过1.5就要关注。
原因:频繁增删不同大小的key、大量大key删除。
优化方案:
- 4.0+支持
MEMORY PURGE主动清理碎片(效果有限); - AOF重写:AOF rewrite会把数据重新持久化,加载时重新规整内存;
- 安全重启:先bgsave,停服务再重启,加载RDB/AOF重建内存,碎片清零;
注意:重启要做好容灾,避免流量真空。
连接泄漏:业务忘记释放连接,必须使用连接池
说明 :客户端拿到连接之后,使用完不归还,持续占用Redis连接,直到达到maxclients上限,新请求无法建立连接,报连接失败。
危害:连接数打满,服务不可用。
优化方案:
- 强制使用连接池(Lettuce默认池、Jedis连接池),由池管理获取和归还;
- 设置连接池最大、最小空闲连接、空闲连接超时自动回收;
- 监控连接数量,告警
connected_clients; - 避免短连接频繁创建销毁。
批量操作优先Pipeline
说明:默认每一条Redis命令都是一次网络往返(RTT),多次往返网络开销大。
Pipeline:客户端一次性打包多条命令发给Redis,Redis批量执行后一次性返回结果,减少网络RTT。
适用:一批无依赖的读写命令(批量set、批量get)。 注意:
- 不是事务,中间命令失败不会回滚;
- 不要一次打包上万条,避免数据包过大、Redis缓冲区压力高;
- 有原子要求用Lua脚本。
集群避免跨slot多key操作
说明 :Redis Cluster 按照hash slot分片,一个key归属一个slot;MGET/MSET、事务、Lua脚本如果包含多个key,落在不同slot会报错。 危害:命令直接失败。
方案:
- 同slot方案:Hash Tag
{tag}:key1{tag}:key2,保证大括号内一样的key落到同一个slot; - 放弃批量原子,分多次请求;
- 业务设计时尽量把关联数据放到同一个slot。
合理控制过期时间,避免集中过期
说明:大量key在同一时刻过期,Redis主线程要清理大量过期key,CPU突增、请求延迟飙升,属于缓存雪崩诱因之一。
原因:批量导入数据时统一设置相同TTL。
优化方案:
- 过期时间增加随机偏移量,例如原本过期1小时,设置 3600 + random(0,600),打散过期时间;
- 不要大批量同时设置一模一样的过期时间;
- 监控过期key数量
expired_keys。
15. Redis 10大业务场景汇总

1. 热点数据缓存
命令:String / Hash
场景:商品详情、首页banner、分类列表、配置信息等访问量大、改动少的数据
原理:把DB查询结果放到Redis,请求优先读Redis,减少MySQL压力;设置过期时间+主动更新缓存。
优点:响应快、扛高并发;
注意:缓存穿透、击穿、雪崩、缓存和数据库一致性问题。
2. 计数器、限流(INCR)
命令 :INCR / INCRBY(String)
- 计数器 :文章阅读量、视频播放量、接口调用次数;每次访问
INCR key,定时把数值落库。 - 简单限流:比如限制一个IP每分钟最多访问100次:key=ip+时间窗口,INCR,超过阈值拒绝请求。
注意:INCR是原子操作,并发安全;限流常用变种:滑动窗口限流。
3. Session共享登录
命令:String / Hash
场景:多服务器集群部署,用户登录session不能存在单机内存。
做法:登录成功生成token,token作为key,用户信息作为value存入Redis,设置过期时间;所有服务统一从Redis校验token。
优点:无状态,方便负载均衡、弹性扩缩容;
替代:现在很多用JWT,但JWT无法主动踢下线,Redis存session适合需要强注销的业务。
4. 分布式锁
命令 :SET key value NX EX(String)
场景:分布式集群下,保证同一时间只有一个服务执行业务(订单扣库存、重复提交、定时任务防重复执行)
核心要点:
- NX:key不存在才设置(抢锁)
- EX:自动过期,防止宕机死锁
- 释放锁必须校验value(防止别人误删锁),用Lua脚本保证原子释放
注意:Redis锁不是强一致性锁,适合业务锁;金融强一致性推荐Zookeeper。
5. ZSet 排行榜
命令:ZSet(有序集合)
场景:积分排行榜、粉丝榜、竞赛排名、销量榜
原理:member=用户ID,score=分数;
常用命令:ZADD加分、ZREVRANGE从高到低取榜单、ZSCORE查单个用户分数、ZRANK查排名。
优点:自带排序,实时榜单;支持分页。
6. Bitmap 签到统计
命令:Bitmap(底层String)
场景:用户每日签到、打卡 原理:bit下标代表用户id/日期,bit位0=未签到,1=已签到
命令:SETBIT签到,GETBIT查询是否签到,BITCOUNT统计签到总人数
优势:极度省内存,千万用户签到只需要MB级别内存;
局限:只适合二元状态(是/否)。
7. HyperLogLog UV统计
命令:HyperLogLog
场景:页面访问UV(独立访客)、活动独立用户统计
原理:概率基数算法,不是精准计数,有0.81%左右误差;
命令:PFADD添加访客id,PFCOUNT获取uv值
优点:内存极小,统计上亿UV也只占用十几KB;
局限:只能统计去重总数,不能拿到明细用户、不适合PV。
8. Geo 附近门店
命令:GEO
场景:附近的店铺、骑手、网约车、周边商家 原理:存储经纬度(lng,lat)
命令:GEOADD存入门店坐标,GEORADIUS根据当前坐标,查询半径范围内的门店,自带距离排序。
局限:底层基于Zset,不适合超大规模地图业务,高德百度地图服务更专业。
9. Stream 轻量消息队列
命令:Stream
场景:异步通知、日志上报、简单异步任务(轻量MQ)
特点:Redis5.0+提供,支持消息持久化、消费组、ack确认、阻塞消费、消息回溯;
对比:比List/发布订阅(PubSub)可靠,PubSub消息不持久化,宕机丢消息;
局限:没有死信队列、消息重试机制弱,高可靠业务还是RocketMQ/Kafka。
10. Hash 购物车
命令:Hash
场景:用户购物车
设计:key = cart:{userId},field=商品ID,value=购买数量+选中状态等
命令:HSET添加商品、HINCRBY增减数量、HGETALL拉取整个购物车、HDEL删除商品
优点:结构贴合购物车,不需要序列化整个购物车,支持单独修改某个商品,读写灵活。
16. 对比速查表
事务 / Lua / Pipeline
|------------------|---------------|--------|------|---------|
| | 原子性 | 服务端逻辑 | 网络次数 | 集群跨slot |
| MULTI 事务 | 是(串行入队执行,无回滚) | 仅命令队列 | 多次 | 不支持 |
| Lua 脚本 | 是 | 支持判断逻辑 | 一次 | 不支持 |
| Pipeline | 不保证原子 | 纯打包 | 一次 | 可以 |
缓存三大问题
|--------|--------------------|---------------|
| 问题 | 现象 | 方案 |
| 穿透 | 查询不存在key,一直打DB | 布隆、缓存空值 |
| 击穿 | 单个热点key过期 | 互斥锁、逻辑过期 |
| 雪崩 | 大批量key同时失效/redis宕机 | 随机过期、高可用、熔断降级 |
Session(Redis) vs JWT
- Redis Session:服务端存状态,可以主动下线;需要Redis;
- JWT:无状态,存在客户端;无法直接踢下线;适合无状态微服务。
安全重点
bind限制IP + requirepass密码 + protected-mode + ACL细粒度权限 + 高危命令改名,多层防护。
内存淘汰
maxmemory达到上限,写请求触发淘汰;优先推荐allkeys-lru。