Redis 学习文档

参考资料:

Redis 教程 | 菜鸟教程

Redis - Real-time data for agents & apps

【超级详细】一文搞懂redis的所有知识点 - 知乎

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水平触发

  1. LT 水平触发(Level Triggered,默认模式)

原理

只要 socket 的内核缓冲区**还有可读/可写数据**,epoll_wait 就会持续返回这个 fd,一直通知你。

  • 只要缓冲区有数据 → 每次 epoll_wait 都上报事件

  • 直到你把缓冲区数据全部读完为止,才不再通知

流程

  1. 网卡收到数据,内核读缓冲区有内容

  2. epoll_wait 返回该 fd 可读事件

  3. 业务读一部分数据,**缓冲区还剩数据**

  4. 再次调用 epoll_wait,**仍然会再次返回这个fd**

优点

  • 简单、容错高;就算一次没读完,下次还会提醒

  • 不容易丢事件,代码好写

缺点

  • 如果忘记读完缓冲区,会反复触发事件,造成epoll_wait频繁唤醒(惊群/频繁循环)
  1. ET 边缘触发(Edge Triggered)

原理

只有状态发生变化的一瞬间才触发一次:也就是只有当数据从【无】变成【有】的那一刻,通知一次。

缓冲区已有数据、后续新增数据才会触发;缓冲区里旧的剩余数据不会重复通知!

流程

  1. 网卡收到数据,缓冲区从空→有数据,触发一次可读事件

  2. epoll_wait 返回fd

  3. 业务只读取一部分,缓冲区还有残留数据

  4. 缓冲区还有数据,但不会再通知了!除非再来新数据

硬性要求(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)

  1. 绝大多数操作是内存操作,本身极快,瓶颈不在计算,而在大量TCP连接管理;
  2. epoll让单一线程可以监听海量客户端连接;
  3. 规避阻塞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`:提示服务器单次期望返回多少元素,**不是精确数量限制,只是参考值**

补充重点:

  1. `EXPIRE` 只能作用于 key,不是 value;过期是 key 层面的机制

  2. `RENAME`:如果 key 带过期时间,重命名后过期时间会继承到新 key

  3. SCAN 是迭代器,**不保证快照一致性**,遍历期间 key 新增 / 删除,可能漏或者重复读到

  4. 禁止生产直接 `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种淘汰策略完整说明

  1. noeviction(默认):不淘汰,写请求直接返回OOM错误,线上一般不用
  2. allkeys-lru:所有 key 中,淘汰最近最少使用 LRU (生产最常用)
  3. volatile-lru:只在设置了过期时间的key里,淘汰LRU
  4. allkeys-lfu:所有key,淘汰访问频次最低(LFU,Redis0+)
  5. volatile-lfu:只过期key,LFU
  6. allkeys-random:所有key随机删
  7. volatile-random:过期key随机删
  8. volatile-ttl:过期key里优先删剩余存活时间最短的

LRU 和 LFU 区别

  • LRU:看时间recently------最近有没有访问,很久没访问优先删;
  • LFU:看频次frequently------访问次数,冷门低频key优先删;适合长期热点稳定场景。

Redis的LRU不是精确LRU:采用抽样,节省内存,近似效果足够业务使用。

补充:hz参数

hz 10:控制Redis后台定时任务频率(过期检查、统计、关闭超时连接等),最高可到500,越高CPU消耗越大。


5. 数据类型 + 底层编码

基础5种

  1. String:
    1. 底层SDS(C语言的字符串是char\[\]实现的,而Redis使用SDS(simple dynamic string) 封装);
    2. 二进制安全,最大512M;
    3. 计数器、缓存JSON、SETNX锁
  2. List:
    1. 底层quicklist(ziplist压缩列表 + 双向链表);
    2. 头尾O(1);
    3. 消息队列、时间线
  3. Set:
    1. 底层intset(全整数、数量少)/ hashtable;
    2. 无序去重;
    3. 交集并集、抽奖
  4. Hash:底层ziplist / hashtable;field-value;对象存储、购物车
  5. 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瞬间复制全部内存,减少开销

触发方式

  1. save:同步阻塞,主线程直接生成RDB,大数据量会阻塞服务,线上禁止使用
  2. bgsave:后台异步,fork子进程做快照,主线程继续处理命令(日常自动持久化底层就是bgsave)
  3. 配置自动save规则:save 900 1 这类配置,满足【时间+修改key数量】条件自动触发bgsave

优缺点

  • 优点
    • 二进制紧凑文件,体积小;宕机恢复速度很快,适合冷备份、异地备份
  • 缺点
    • 两次快照之间的写数据没有落地,故障时会丢失这段时间的数据
    • fork子进程有短暂CPU、内存开销;内存越大,fork耗时越高

AOF 追加日志

机制

以协议文本形式记录每一条写命令,追加写入AOF文件末尾

appendfsync 刷盘策略(核心)

    1. always:每执行一条写命令就调用fsync强制刷磁盘。数据最安全,几乎不丢数据;磁盘IO压力极大,性能很差
    2. everysec(默认推荐):后台线程每秒执行一次fsync刷盘。最坏情况最多丢失1秒数据,安全性和性能均衡
    3. 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头部)

补充要点

  1. AOF重写、bgsave都是fork子进程,会复用COW机制;
  2. 混合持久化≠同时独立开启RDB+AOF,是AOF文件内部融合RDB快照;
  3. 如果同时开启RDB+AOF,启动依旧优先读AOF;
  4. AOF文件损坏时,可以用 redis-check-aof 修复;RDB用 redis-check-rdb。

7. 事务、Lua、Pipeline、Pub/Sub【扩充事务完整机制】

7.1 Redis 事务 MULTI / EXEC / DISCARD / WATCH

Redis事务本质:

命令入队,一次性串行执行,不支持回滚 执行三阶段:

  1. MULTI:开启事务,客户端进入事务状态;
  2. 后续命令入队列,不立即执行,只返回QUEUED;
  3. 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节点上存储不同的内容。

  1. 16384 slot哈希槽,CRC16(key)%16384;
  2. 3主3从起步;
  3. 分片扩容+故障转移;
  4. 限制:跨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;恶意传非法参数也会大量打库。

解决方案:

  1. 布隆过滤器:提前把所有合法主键放入布隆过滤器,查询先过过滤器,不存在直接拦截;
  2. 缓存空值:查不到数据时,往Redis写入一个短期过期的空标记;
  3. 参数前置校验:校验ID、手机号等参数格式,非法参数直接拒绝。

缓存击穿

场景:热点 key 到期瞬间,大量并发请求同时进来,缓存失效,全部打到数据库。

解决方案:

  1. 互斥锁:缓存失效时,只放行一个请求去更新缓存,其他请求等待重试;
  2. 逻辑过期:key设置为永不过期,value里存逻辑过期时间,后台异步线程刷新缓存,请求不用等过期。

key 不设置 Redis 的 TTL ,把过期时间放到 value 内。

javascript 复制代码
{
  "data": "商品数据",
  "expireTime": 1765432100  // 逻辑过期时间(时间戳)
}

请求发现逻辑时间过期后,先返回旧数据,再通过锁控制单独一个线程异步更新缓存,其他请求直接返回旧值,避免并发打数据库,适合允许短暂脏数据的热点场景。

缓存雪崩

场景:大批量缓存key同一时间集中过期,或者Redis整体宕机,大量流量瞬间压垮数据库。

解决方案:

  1. 过期时间增加随机偏移量,打散过期时间;
  2. Redis集群高可用(哨兵/Cluster),避免单点宕机;
  3. 接入限流、熔断、降级机制;
  4. 多级缓存架构:本地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 网络层面

  1. 绑定 IP bind:默认bind 127.0.0.1,只允许本机访问;不要 bind 0.0.0.0 直接暴露公网;需要外部访问指定内网IP。

    bind 127.0.0.1 192.168.1.10

  2. 防火墙策略:只放行业务服务器IP访问6379,拒绝陌生IP;

  3. 端口修改:修改默认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。

流程

  1. 用户登录成功,服务生成唯一sessionId;
  2. 把用户登录信息序列化存入Redis,key=sessionId,设置过期时间(如30分钟);
  3. 返回sessionId写入浏览器Cookie / 返回前端Token;
  4. 后续请求携带sessionId,服务从Redis读取用户信息;
  5. 退出登录:DEL sessionId;
  6. 续期:每次访问刷新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

必须配置告警:

  1. Redis进程宕机;
  2. RDB/AOF持久化失败;
  3. 内存使用率接近maxmemory;
  4. 缓存命中率持续下降;
  5. 主从同步断开;
  6. 慢查询数量突增;
  7. 连接数打满、拒绝连接;
  8. 内存碎片率过高。

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

危害:

  1. 读写耗时变长,阻塞Redis;
  2. 迁移key(集群扩容、槽迁移)时卡顿;
  3. 删除大key会产生大量内存释放,造成主线程阻塞。 优化方案:
  • 拆分:把一个大Hash拆成多个小Hash;
  • 禁止HGETALL、LRANGE 0 -1一次性全拉;
  • 使用HSCAN、ZSCAN、SSCAN迭代分批读取;
  • 删除大key不要直接DEL,分批删除。

热key:超高QPS访问同一个key;本地二级缓存、主从副本分流

说明:某个key访问量远高于其他key(比如首页爆款商品),流量打在同一个Redis节点,打满节点CPU。

危害:单节点CPU打满,其他节点空闲,流量倾斜,容易超时雪崩。 优化方案:

  1. 本地二级缓存(Caffeine、Guava Cache),应用内存缓存一份,减少Redis请求;
  2. 读写分离,读请求打到从节点副本分流;
  3. 热key副本:复制多份相同key散落到不同slot;
  4. 限流保护。

内存碎片:碎片率高;重启、AOF重写

说明:Redis分配、释放内存后,产生很多零散小块内存,无法复用,内存占用高于实际数据大小,碎片率=碎片内存/已分配内存。

碎片查看:INFO memory 看 mem_fragmentation_ratio,一般超过1.5就要关注。

原因:频繁增删不同大小的key、大量大key删除。

优化方案:

  1. 4.0+支持 MEMORY PURGE 主动清理碎片(效果有限);
  2. AOF重写:AOF rewrite会把数据重新持久化,加载时重新规整内存;
  3. 安全重启:先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会报错。 危害:命令直接失败。

方案:

  1. 同slot方案:Hash Tag {tag}:key1 {tag}:key2,保证大括号内一样的key落到同一个slot;
  2. 放弃批量原子,分多次请求;
  3. 业务设计时尽量把关联数据放到同一个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。

相关推荐
我不会起名字3221 小时前
WebSocket 停机与在线状态:Shutdown 返回后还需要清理什么
redis·后端·websocket·go·即时通讯·im·故障排查
七夜zippoe1 小时前
多轮对话管理:Session/记忆在 Java 后端怎么存(存储设计实战)
java·开发语言·ai·session·记忆
web安全成长日记1 小时前
DNS解析全过程:从递归查询、根域与权威 DNS 到缓存 TTL|网络安全其实很简单
安全·web安全·缓存
qingwufeiyang_5301 小时前
Docker学习笔记2
笔记·学习
时间的拾荒人2 小时前
Redis 典型应用:缓存与分布式锁原理
redis·分布式·缓存·面试·架构
苏三说技术2 小时前
为什么越来越多人用 OnlyOffice ?
后端
回家路上绕了弯2 小时前
RAG:把知识库接进大模型,然后呢?
后端
Z21-X2 小时前
云原生运维学习笔记:从操作系统底层到 Kubernetes 集群的深度实践
运维·笔记·学习·云原生·kubernetes