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(内存数据库)。


Redis INCR 命令

初识 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/s50ms
Redis INCR约 8000 ops/s0.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❌✅低并发、演示用
Pipeline1❌✅低并发、要求低延迟
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 次。

三个查询接口的对比:

接口命令时间复杂度往返
获取点赞数GETO(1)1
判断是否点赞SISMEMBERO(1)1
列表页批量MGET + PipelineO(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 命令为什么是原子操作?底层原理是什么?

RedisINCR原子性

解题思路:

这道题问的是 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

解题思路:

这道题问的是用 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 数据结构有哪些常用命令?分别适用于点赞场景的哪些功能?

RedisSet数据结构

解题思路:

这道题问的是 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

如何实现”批量点赞”功能,用户可以一次性对多篇文章点赞?

Redis批量操作Pipeline

解题思路:

这道题问的是『一次点赞多篇怎么才快』,核心是『把 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 命名规范,便于管理和维护?

RedisKey命名最佳实践

解题思路:

这道题问的是 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 监控和维护:

最佳实践总结:

  1. 使用冒号分隔层级
  2. Key 名称包含业务、对象、ID、属性
  3. 定义 Key 前缀常量
  4. 使用工厂方法创建 Key
  5. 为短期数据设置过期时间
  6. 定期监控和清理 Key
  7. 避免 Key 名称过长(影响内存和性能)
  8. 团队内统一命名规范

最终答案:

遵循 {业务}:{对象}:{ID}:{属性} 的格式(如 article:123:like_count、article:123:liked_users、user:1001:profile),用冒号分隔层级,让 key 自解释且便于按前缀批量扫描与清理。同时配套四件事:把前缀定义为常量并用工厂方法生成 key、为短期数据设置过期时间、定期监控 key 数量与内存占用、按前缀做批量管理。命名要兼顾可读性与长度,避免过长。


思考题

  1. 如果 Redis 内存不足,如何优化点赞数据的存储?

  2. 如何实现”点赞数据迁移”,从数据库迁移到 Redis?

  3. 如果需要支持”点赞数据分析”(如每小时点赞趋势),如何设计 Redis 数据结构?

💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。

发现内容有问题?

告诉我们哪里需要改进。