INCR 命令
数据库方案上线两周后,我遇到了第一个真正的挑战。
那天是周五晚上,平台推送了一篇爆款文章:《创业者的一天》。
数据飙升:
文章发布时间:18:00
发布后 1 小时:500 阅读,50 点赞
发布后 2 小时:2000 阅读,300 点赞
发布后 3 小时:5000 阅读,800 点赞
发布后 4 小时:10000 阅读,1500 点赞
峰值:每秒约 50 个点赞请求!
系统报警:
【监控报警】数据库 CPU 使用率超过 80%
【监控报警】数据库连接数接近上限
【监控报警】慢查询数量增加
我赶紧查看数据库监控:
MySQL 状态:
- CPU:85%
- 连接数:180/200
- QPS:1500
- 平均响应时间:200ms
慢查询日志:
- INSERT INTO article_likes:平均 50ms
- UPDATE articles SET like_count...:平均 150ms
数据库扛不住了!
我分析了原因:
点赞操作:
1. INSERT INTO article_likes (article_id, user_id)
2. UPDATE articles SET like_count = like_count + 1
瓶颈分析:
- INSERT 操作:需要检查唯一索引,写入磁盘
- UPDATE 操作:需要锁定记录,写入磁盘
- 磁盘 IO:每次操作都需要写磁盘
- 锁竞争:大量并发 UPDATE 导致锁等待
核心问题:磁盘 IO 和锁竞争。
我在笔记本上画了个图:
用户请求 → 应用服务器 → MySQL(磁盘)
瓶颈:
1. 每次点赞都要写磁盘
2. 磁盘写入速度:约 100 IOPS
3. 50 个并发请求 → 排队等待
如果改用内存:
- 内存读写速度:约 100,000 OPS
- 性能提升:1000 倍!
解决方案:使用 Redis(内存数据库)。
初识 INCR
我打开 Redis 官方文档,找到了 INCR 命令:
INCR key
将 key 中存储的数字值增一。
如果 key 不存在,那么 key 的值会先被初始化为 0 ,然后再执行 INCR 操作。
时间复杂度:O(1)
测试一下:
验证要点
- 命令只用于验证系统状态,读者不需要记具体参数。
完美!一个命令就能完成计数!
INCR 的特性
我研究了 INCR 的关键特性:
特性 1:原子性
INCR 是原子操作:
- 单线程执行,不需要锁
- 不会被其他命令打断
- 高并发下也能正确计数
对比 MySQL:
- MySQL UPDATE 需要锁行
- 高并发时锁等待严重
- 性能下降明显
特性 2:O(1) 时间复杂度
INCR 时间复杂度:O(1)
无论计数器有多大,执行时间都是常数:
- 计数器值为 100:执行时间约 0.1ms
- 计数器值为 1000000:执行时间还是约 0.1ms
对比 MySQL COUNT:
- COUNT(*) 时间复杂度:O(n)
- 点赞数越多,查询越慢
特性 3:内存操作
Redis 数据存储在内存中:
- 内存读写速度:纳秒级
- 磁盘读写速度:毫秒级
- 性能差异:1000 倍以上
性能测试
我用 Redis 做了压力测试:
对比数据库:
| 方案 | 吞吐量 | 平均响应时间 |
|---|---|---|
| MySQL UPDATE | 约 200 ops/s | 50ms |
| Redis INCR | 约 8000 ops/s | 0.1ms |
| 性能提升 | 40 倍 | 500 倍 |
我决定立刻引入 Redis!
数据结构设计
我在 Redis 中设计了两种数据结构:
为什么需要两种结构?
计数器(like_count):
- 快速获取点赞总数
- INCR/DECR 操作,性能极高
点赞集合(liked_users):
- 判断用户是否点赞
- SADD/SREM/SISMEMBER 操作
- 防止重复点赞
点赞接口实现
点赞要同时更新计数器和点赞集合,而且这两个更新必须原子完成——否则就会出现本章开头那个”集合去重了但计数多加了一次”的错误。
def like_article(article_id, user_id):
"""点赞:计数器 INCR + 点赞集合 SADD"""
count_key = f"article:{article_id}:like_count"
liked_key = f"article:{article_id}:liked_users"
# 先判断是否已经赞过,保证幂等
if redis.sismember(liked_key, user_id):
# 已赞过:直接返回当前计数,不重复加
return {
"liked": True,
"changed": False,
"like_count": int(redis.get(count_key) or 0),
}
# 没有赞过:加入集合并计数 +1
redis.sadd(liked_key, user_id)
new_count = redis.incr(count_key)
return {"liked": True, "changed": True, "like_count": new_count}
对应的 Redis 命令:
SISMEMBER article:123:liked_users 1001
(integer) 0
SADD article:123:liked_users 1001
(integer) 1
INCR article:123:like_count
(integer) 101
三个 Redis 命令意味着三次网络往返。
客户端 → Redis: SISMEMBER → 客户端 → Redis: SADD → 客户端 → Redis: INCR
↑____________↑____________________↑
3 次网络往返,每次 ~0.3ms
用 Pipeline 可以压缩到 1 次往返,但仍然不是原子的。
def like_article_pipelined(article_id, user_id):
"""Pipeline 版本:减少往返,但不保证原子"""
count_key = f"article:{article_id}:like_count"
liked_key = f"article:{article_id}:liked_users"
pipe = redis.pipeline()
pipe.sismember(liked_key, user_id)
pipe.sadd(liked_key, user_id)
pipe.incr(count_key)
results = pipe.execute()
Pipeline 的问题是:批量命令之间仍然可以被打断。
时间线:
T1: 线程 A SISMEMBER → 0(未赞过)
T2: 线程 B SISMEMBER → 0(未赞过) ← 两个请求都通过了检查
T3: 线程 A SADD → 1
T4: 线程 B SADD → 0 ← Set 去重,集合正确
T5: 线程 A INCR → 101
T6: 线程 B INCR → 102 ← 计数多了 1 ❌
要彻底解决这个问题,必须用 Lua 脚本把三个命令合成一个原子操作。
def like_article_atomic(article_id, user_id):
"""Lua 版本:保证幂等 + 原子"""
return redis.eval(
LIKE_SCRIPT, 2,
f"article:{article_id}:liked_users",
f"article:{article_id}:like_count",
user_id,
)
完整脚本见《Lua 脚本》一章。三个方案的取舍:
| 方案 | 网络往返 | 原子性 | 幂等 | 适用 |
|---|---|---|---|---|
| 三条命令 | 3 | ❌ | ✅ | 低并发、演示用 |
| Pipeline | 1 | ❌ | ✅ | 低并发、要求低延迟 |
| Lua 脚本 | 1 | ✅ | ✅ | 生产环境 |
SADD 的返回值天然提供了幂等性信息。
SADD 返回 1 → 新增了一个成员(真的首次点赞)
SADD 返回 0 → 成员已存在(之前赞过)
所以”是否首次点赞”这个信息不需要额外的 SISMEMBER 查询。Lua 脚本里就是靠它来决定要不要 INCR 的。
生产环境推荐的写法:
def like_article(article_id, user_id):
"""生产版:Lua 脚本保证原子性和幂等"""
count_key = f"article:{article_id}:like_count"
liked_key = f"article:{article_id}:liked_users"
changed, count = redis.eval(
LIKE_SCRIPT, 2, liked_key, count_key, user_id
)
return {"liked": True, "changed": bool(changed), "like_count": count}
取消点赞接口
取消点赞是对称的操作:SREM 移除集合成员,DECR 减少计数。
def unlike_article(article_id, user_id):
"""取消点赞:SREM + DECR"""
count_key = f"article:{article_id}:like_count"
liked_key = f"article:{article_id}:liked_users"
# 先判断是否赞过
if not redis.sismember(liked_key, user_id):
# 没赞过:幂等返回,不减计数
return {
"liked": False,
"changed": False,
"like_count": int(redis.get(count_key) or 0),
}
redis.srem(liked_key, user_id)
new_count = redis.decr(count_key)
return {"liked": False, "changed": True, "like_count": new_count}
对应的 Redis 命令:
SISMEMBER article:123:liked_users 1001
(integer) 1
SREM article:123:liked_users 1001
(integer) 1
DECR article:123:like_count
(integer) 100
SREM 的返回值同样提供了幂等性信息。
SREM 返回 1 → 真的删掉了一个成员(之前赞过)
SREM 返回 0 → 成员不存在(本来就没赞过)
取消点赞比点赞更容易出错的地方:计数不能减成负数。
用户点了取消,但 SREM 因为并发已经删过了(返回 0)
→ 如果代码不看返回值,照样执行 DECR
→ 计数被多减了 1 ❌
所以判断顺序很重要:先看 SREM 的返回值,再决定要不要 DECR。
错误写法:
redis.srem(liked_key, user_id)
redis.decr(count_key) # ← 不管删没删成功都减
正确写法(Lua 里):
local removed = redis.call('SREM', KEYS[1], ARGV[1])
if removed == 0 then
return {0, tonumber(redis.call('GET', KEYS[2]) or '0')}
end
local count = redis.call('DECR', KEYS[2])
if count < 0 then
redis.call('SET', KEYS[2], 0)
count = 0
end
return {1, count}
DECR 之后加一道 count < 0 的兜底。
正常情况下不会触发,但它能挡住”历史数据被改坏”的极端情况。代价是计数会停在 0 而不是负数——负数会让页面显示”-1 个赞”,这种 bug 会被用户直接看到。
取消点赞的一致性检查:
点赞后:
SISMEMBER → 1
SCARD liked_users = 101
GET like_count = 101
✅ 集合大小和计数相等
取消点赞后:
SISMEMBER → 0
SCARD liked_users = 100
GET like_count = 100
✅ 相等
SCARD 的结果应该永远等于 like_count。
这是监控系统必须断言的不变量:
不一致 = |SCARD(liked_users) - GET(like_count)|
正常应该恒为 0
不为 0 说明有并发写入没被正确处理
获取点赞数
获取点赞数是最简单的操作:一次 GET。
def get_like_count(article_id):
"""获取点赞总数"""
count_key = f"article:{article_id}:like_count"
value = redis.get(count_key)
return int(value) if value is not None else 0
对应的 Redis 命令:
GET article:123:like_count
"101"
O(1) 时间复杂度,与点赞数的大小无关。
对比 MySQL:
SELECT COUNT(*) FROM article_likes WHERE article_id = 123
- 需要扫描索引,点赞越多越慢
- 10 万个赞要扫描 10 万条索引记录
对比 Redis:
GET article:123:like_count
- 直接定位 key 并读取值
- 无论计数是 101 还是 10,000,000,耗时都是常数
key 不存在时返回 0 而不是报错。
GET article:999:like_count
(nil)
Python 侧:
value = redis.get(count_key)
return int(value) if value is not None else 0
这个兜底很重要——文章刚创建、还没被赞过时,key 根本不存在。如果不做处理,页面会抛 TypeError。
列表页要一次取回所有文章的计数。
def get_like_counts(article_ids):
"""批量获取:一次 MGET 取回所有计数"""
keys = [f"article:{aid}:like_count" for aid in article_ids]
values = redis.mget(keys)
return {
aid: (int(v) if v is not None else 0)
for aid, v in zip(article_ids, values)
}
MGET article:1:like_count article:2:like_count article:3:like_count
1) "101"
2) "256"
3) "42"
MGET 把 N 次往返压缩成 1 次。
逐条 GET:20 次往返 ≈ 6ms
一次 MGET:1 次往返 ≈ 0.3ms
别忘了批量查点赞状态也要一起做。
def get_article_list_with_like_status(article_ids, user_id):
"""列表页:一次拿到所有点赞数和当前用户的点赞状态"""
count_keys = [f"article:{aid}:like_count" for aid in article_ids]
liked_keys = [f"article:{aid}:liked_users" for aid in article_ids]
pipe = redis.pipeline()
for key in count_keys:
pipe.get(key)
for key in liked_keys:
pipe.sismember(key, user_id)
results = pipe.execute()
counts = results[:len(article_ids)]
liked = results[len(article_ids):]
return [
{
"article_id": aid,
"like_count": int(c) if c is not None else 0,
"liked": bool(l),
}
for aid, c, l in zip(article_ids, counts, liked)
]
这样列表页的 Redis 操作只有 1 次往返,而不是 40 次。
三个查询接口的对比:
| 接口 | 命令 | 时间复杂度 | 往返 |
|---|---|---|---|
| 获取点赞数 | GET | O(1) | 1 |
| 判断是否点赞 | SISMEMBER | O(1) | 1 |
| 列表页批量 | MGET + Pipeline | O(N) | 1 |
这三个接口就是 Redis 方案相对数据库方案的全部性能来源。 后面的《分片计数》《本地缓存》《合并写入》都是在这个基础上继续优化。
判断是否点赞
MySQL 方案:
- 点赞接口:平均 50ms
- 获取点赞数:平均 100ms(需要 COUNT)
- 判断是否点赞:平均 80ms
Redis 方案:
- 点赞接口:平均 0.5ms
- 获取点赞数:平均 0.1ms
- 判断是否点赞:平均 0.1ms
提升倍数:100 倍!
### 吞吐量
压力测试:1000 个并发用户点赞同一篇文章
MySQL:
- 最大吞吐量:约 200 ops/s
- 响应时间:随着并发增加,从 50ms 上升到 500ms+
Redis:
- 最大吞吐量:约 8000 ops/s
- 响应时间:始终保持在 1ms 以下
提升倍数:40 倍!
### 系统负载
MySQL CPU:
- 优化前:85%
- 优化后:15%(只处理其他业务)
Redis CPU:
- 约 5%
服务器资源:
- MySQL 压力大幅降低
- Redis 资源占用很小
- 整体系统更稳定
## 实际效果
### 爆款文章测试
我用 Redis 方案重新测试了爆款文章:
文章:《创业者的一天》 发布时间:周五 18:00
数据:
- 4 小时内:10000 阅读,1500 点赞
- 峰值:每秒 50 个点赞请求
Redis 监控:
- CPU:5%
- 内存:约 10MB
- 响应时间:平均 0.3ms
系统状态:
- 无报警
- 无慢查询
- 用户体验流畅
**完美!系统轻松应对爆款文章。**
### 用户反馈
用户 A:“点赞秒响应,体验太好了!” 用户 B:“之前点赞要等好几秒,现在瞬间完成” 作者 C:“看到点赞数快速增加,很有成就感” “
虽然 Redis 性能很好,但我开始担心一些问题:
问题 1:数据持久化
Redis 数据存储在内存中:
- 如果 Redis 宕机,数据会丢失吗?
- 如果服务器断电,点赞数还能恢复吗?
我需要数据持久化方案。
问题 2:数据同步
Redis 和数据库的数据如何同步?
- 用户点赞后,Redis 计数 +1
- 数据库的 article_likes 表怎么办?
- 如何保证数据一致性?
问题 3:内存限制
Redis 内存有限:
- 如果点赞数越来越多,内存够吗?
- 10000 篇文章 × 每篇平均 1000 点赞 × 每个记录 100 字节
- 大约需要 1GB 内存
- 如果增长到 10 倍?100 倍?
问题 4:冷启动
系统重启后,Redis 数据如何初始化?
- 从数据库加载所有点赞数?
- 10000 篇文章,需要多久?
- 启动时间会很长吗?
练习 1
Redis INCR 命令为什么是原子操作?底层原理是什么?
解题思路:
这道题问的是 INCR 的原子性来源,要从 Redis 的单线程执行模型讲起,再解释为什么单线程还能有高性能,最后界定原子性的适用范围。
详细步骤:
Redis INCR 的原子性原理:
原因:Redis 是单线程执行命令
Redis 执行模型:
1. 所有命令在单个线程中顺序执行
2. 一个命令执行期间,不会被其他命令打断
3. 不需要锁机制,天然保证原子性
对比多线程数据库:
- MySQL:多线程,需要锁来保证原子性
- Redis:单线程,天然原子性底层实现:
为什么单线程也能高性能?
Redis 性能分析:
纯内存操作:
- 内存读写速度:纳秒级
- 无磁盘 IO 等待
单线程优势:
- 无锁竞争开销
- 无上下文切换开销
- 无多线程同步复杂度
高效 IO 多路复用:
- epoll/kqueue 等机制
- 一个线程处理多个连接
- 不会阻塞等待网络 IO
结论:单线程 + 内存 + IO 多路复用 = 极高性能INCRBY 命令:
验证要点
- 命令只用于验证系统状态,读者不需要记具体参数。
原子性保证范围:
单命令原子性:
- INCR、INCRBY、DECR、DECRBY:都是原子操作
- SET、GET:也是原子操作
- SADD、SREM:原子操作
多命令原子性:
- 需要使用 MULTI/EXEC(事务)
- 或使用 Lua 脚本
示例:非原子性的多命令
127.0.0.1:6379> GET counter
"100"
127.0.0.1:6379> INCR counter
"101"
问题:GET 和 INCR 之间,可能有其他客户端修改 counter最终答案:
INCR 的原子性来自 Redis 的单线程命令执行模型——所有命令在同一个线程中顺序执行,一条命令执行期间不会被其他命令打断,因此『读—改—写』天然不可分割,不需要额外加锁。单线程仍能高性能,靠的是纯内存操作(纳秒级)、无锁竞争与上下文切换开销、以及 IO 多路复用(epoll/kqueue)让一个线程处理多个连接。注意原子性只覆盖单条命令:GET 与 INCR 两条命令之间仍可能被其他客户端插入,需要原子性组合时要用 MULTI/EXEC 或 Lua 脚本。
练习 2
如何用 Redis 实现”限流器”功能,限制用户每分钟最多点赞 10 次?
解题思路:
这道题问的是用 Redis 做固定窗口限流,要抓住一个核心陷阱——INCR 和 EXPIRE 不是原子的。
详细步骤:
限流器实现方案:
方案 1:INCR + EXPIRE
问题:INCR 和 EXPIRE 不是原子操作
并发问题:
T1: GET key → None
T2: GET key → None(同时)
T1: SET key 1 EX 60
T2: SET key 1 EX 60(覆盖了 T1 的设置)
解决方案:使用 Lua 脚本方案 2:Lua 脚本(原子性)
方案 3:使用 INCR 的原子特性
问题:INCR 和 EXPIRE 不是原子操作,可能出错
场景:
T1: INCR key → 1
T1: (准备设置 EXPIRE)
Redis 宕机!
结果:key 存在,但没有过期时间,永久存储最佳方案:Lua 脚本或使用 SET + NX + EX
滑动窗口限流(更精确)
对比总结:
| 方案 | 精确度 | 原子性 | 实现复杂度 |
|---|---|---|---|
| INCR + EXPIRE | 固定窗口 | 非原子 | 低 |
| Lua 脚本 | 固定窗口 | 原子 | 中 |
| 滑动窗口 | 滑动窗口 | 原子 | 高 |
推荐:一般场景使用 Lua 脚本(固定窗口),严格场景使用滑动窗口。
最终答案:
用 INCR + EXPIRE 实现固定窗口计数,但两条命令不是原子的(并发初始化可能互相覆盖,宕机可能留下无 TTL 的 key),因此必须用 Lua 脚本把『计数 + 设置过期 + 判断是否超限』合成一条原子命令,或用 SET key 0 EX 60 NX 再 INCR。精确要求滑动窗口时用 ZSET 存时间戳做滑动窗口。默认推荐:一般场景用 Lua 脚本(固定窗口),严格限流场景用滑动窗口。
练习 3
Redis 的 Set 数据结构有哪些常用命令?分别适用于点赞场景的哪些功能?
解题思路:
这道题问的是 Set 的命令集到点赞功能的映射,要先列命令与复杂度,再逐条对应业务动作,最后点出 SMEMBERS 的 O(n) 陷阱。
详细步骤:
Redis Set 常用命令:
| 命令 | 功能 | 时间复杂度 | 点赞场景应用 |
|---|---|---|---|
| SADD | 添加元素 | O(1) | 用户点赞 |
| SREM | 移除元素 | O(1) | 取消点赞 |
| SISMEMBER | 判断元素是否存在 | O(1) | 检查是否点赞 |
| SMEMBERS | 获取所有元素 | O(n) | 获取点赞用户列表 |
| SCARD | 获取元素数量 | O(1) | 获取点赞用户数 |
| SPOP | 随机移除元素 | O(1) | 随机抽奖 |
| SRANDMEMBER | 鎷取随机元素 | O(1) | 随机抽奖 |
点赞场景应用:
Set 的优势:
1. 自动去重:
- 一个用户对一篇文章只能点赞一次
- Set 自动保证唯一性
2. 高性能:
- O(1) 时间复杂度的添加、删除、查找
- 适合高频操作
3. 集合运算:
- 可以计算交集、并集、差集
- 适合复杂业务场景集合运算示例:
注意事项:
SMEMBERS 时间复杂度:O(n)
问题:如果 Set 包含大量元素,获取所有元素会很慢
解决方案:
1. 使用 SSCAN 分批获取
2. 只在需要时获取,不频繁调用
3. 限制点赞用户数量(如最多显示前 1000 个)最终答案:
Set 常用命令及点赞场景映射:SADD(O(1),用户点赞)、SREM(O(1),取消点赞)、SISMEMBER(O(1),检查是否已点赞)、SCARD(O(1),获取点赞人数)、SRANDMEMBER/SPOP(O(1),随机展示或抽奖)、SMEMBERS(O(n),获取全部点赞用户)。Set 的优势是天然去重与 O(1) 的增删查。需要注意 SMEMBERS 在大集合上是 O(n),应该用 SSCAN 分批获取,或限制展示的用户数量。
练习 4
如何实现”批量点赞”功能,用户可以一次性对多篇文章点赞?
解题思路:
这道题问的是『一次点赞多篇怎么才快』,核心是『把 N 次网络往返压成 1~2 次』。
详细步骤:
批量点赞实现方案:
方案 1:循环调用
方案 2:Redis Pipeline
方案 3:Lua 脚本(最佳)
性能对比:
批量点赞 20 篇文章:
方案 1(循环调用):
- 网络往返:20 次
- 总耗时:约 100ms
方案 2(Pipeline):
- 网络往返:2 次
- 总耗时:约 10ms
- 提升:10 倍
方案 3(Lua 脚本):
- 网络往返:1 次
- 总耗时:约 5ms
- 提升:20 倍批量取消点赞:
应用场景:
批量点赞功能:
- 用户浏览文章列表,一键点赞所有感兴趣的文章
- 管理员批量操作
- 数据迁移/导入
批量取消点赞:
- 用户取消所有点赞
- 清理测试数据最终答案:
三种实现:循环调用(20 次往返,约 100ms)、Redis Pipeline(2 次往返,约 10ms,提升 10 倍)、Lua 脚本(1 次往返,约 5ms,提升 20 倍,且能保证『判重 + 加计数 + 加成员』的原子性)。生产上优先用 Lua 脚本;批量取消点赞同理,且同样要注意幂等与计数的一致性。
练习 5
如何设计 Redis 的 key 命名规范,便于管理和维护?
解题思路:
这道题问的是 key 命名规范,要先讲清楚『规范要解决什么问题』,再给出格式、示例和配套的管理机制。
详细步骤:
Redis Key 命名规范:
基本原则:
1. 可读性:key 名称应该清晰易懂
2. 结构化:使用分隔符组织层级
3. 唯一性:避免 key 冲突
4. 简洁性:key 名称不要太长
5. 一致性:团队内统一规范推荐格式:
格式:{业务}:{对象}:{ID}:{属性}
示例:
- 点赞计数:article:123:like_count
- 点赞集合:article:123:liked_users
- 用户信息:user:1001:profile
- 会话信息:session:abc123:data点赞场景 Key 设计:
Key 前缀管理:
批量 Key 管理:
Key 过期时间管理:
Key 监控和维护:
最佳实践总结:
- 使用冒号分隔层级
- Key 名称包含业务、对象、ID、属性
- 定义 Key 前缀常量
- 使用工厂方法创建 Key
- 为短期数据设置过期时间
- 定期监控和清理 Key
- 避免 Key 名称过长(影响内存和性能)
- 团队内统一命名规范
最终答案:
遵循 {业务}:{对象}:{ID}:{属性} 的格式(如 article:123:like_count、article:123:liked_users、user:1001:profile),用冒号分隔层级,让 key 自解释且便于按前缀批量扫描与清理。同时配套四件事:把前缀定义为常量并用工厂方法生成 key、为短期数据设置过期时间、定期监控 key 数量与内存占用、按前缀做批量管理。命名要兼顾可读性与长度,避免过长。
-
如果 Redis 内存不足,如何优化点赞数据的存储?
-
如何实现”点赞数据迁移”,从数据库迁移到 Redis?
-
如果需要支持”点赞数据分析”(如每小时点赞趋势),如何设计 Redis 数据结构?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
