阶段2(上):后端专题 Go/Gin/PostgreSQL/MySQL/Redis/MQ/gRPC 的课程、企业场景、面试题和可运行示例
This commit is contained in:
1 parent
0bae9916a9
commit
5eb67c5d08
65 files changed
+6457
-77
No files matched your search
@@ -0,0 +1,102 @@
|
||||
---
|
||||
id: backend.redis.data-structures
|
||||
title: 数据结构和常用命令:String、Hash、List、Set、ZSet、Stream
|
||||
type: lesson
|
||||
domain: backend
|
||||
stack: [redis]
|
||||
tags: [String, Hash, ZSet, Stream, 过期时间]
|
||||
level: basic
|
||||
est_hours: 2
|
||||
related: [backend.redis.cache-patterns, backend.redis.interview]
|
||||
week: [3]
|
||||
order: 1
|
||||
---
|
||||
|
||||
# 数据结构和常用命令:String、Hash、List、Set、ZSet、Stream
|
||||
|
||||
## 解释说明
|
||||
|
||||
| 类型 | 是什么 | 常见用途 | 常用命令 |
|
||||
| --- | --- | --- | --- |
|
||||
| String | 字符串 / 数字 | 缓存 JSON、计数器、验证码 | `SET k v EX 60 NX`、`GET`、`INCR`、`INCRBY` |
|
||||
| Hash | 字段 → 值 | 对象(用户资料、购物车) | `HSET`、`HGET`、`HGETALL`、`HINCRBY` |
|
||||
| List | 双端链表 | 最新列表、简单队列 | `LPUSH`、`RPOP`、`LRANGE`、`BRPOP` |
|
||||
| Set | 无序去重集合 | 标签、点赞用户、共同好友 | `SADD`、`SISMEMBER`、`SINTER` |
|
||||
| ZSet | 按分数排序的集合 | 排行榜、延迟队列(分数=时间) | `ZADD`、`ZINCRBY`、`ZREVRANGE`、`ZRANGEBYSCORE` |
|
||||
| Stream | 追加式日志,支持消费组 | 轻量消息队列 | `XADD`、`XREADGROUP`、`XACK` |
|
||||
|
||||
还有 Bitmap(签到)、HyperLogLog(UV 近似计数)、Geo(附近的人)。
|
||||
|
||||
**关键概念**
|
||||
|
||||
- **单线程执行命令**:每条命令是原子的;多条命令要原子执行用 Lua 脚本或 `MULTI/EXEC`。
|
||||
- **过期时间**:`EX` 秒 / `PX` 毫秒;`TTL` 查看剩余时间。过期删除 = 惰性删除(访问时检查)+ 定期抽样删除。
|
||||
- **内存淘汰策略**:内存满时按 `maxmemory-policy` 淘汰,缓存场景常用 `allkeys-lru` 或 `allkeys-lfu`。
|
||||
- **持久化**:RDB(定时快照)和 AOF(追加命令日志),可以同时开启。
|
||||
|
||||
## 案例
|
||||
|
||||
- 文章阅读数:`INCR article:42:views`,定时批量写回数据库。
|
||||
- 积分排行榜:`ZINCRBY rank:2026-10 10 user:7`,`ZREVRANGE rank:2026-10 0 9 WITHSCORES` 取前 10。
|
||||
- 登录验证码:`SET sms:13800000000 123456 EX 300 NX`,NX 保证 5 分钟内不重复发送。
|
||||
|
||||
## 代码示例
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func main() {
|
||||
url := os.Getenv("REDIS_URL") // 例如 redis://localhost:6379/0
|
||||
if url == "" {
|
||||
fmt.Println("未设置 REDIS_URL,跳过")
|
||||
return
|
||||
}
|
||||
opt, err := redis.ParseURL(url)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
rdb := redis.NewClient(opt)
|
||||
defer rdb.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
// 计数器
|
||||
n, _ := rdb.Incr(ctx, "demo:views:42").Result()
|
||||
fmt.Println("阅读数", n)
|
||||
|
||||
// 排行榜
|
||||
rdb.ZIncrBy(ctx, "demo:rank", 30, "alice")
|
||||
rdb.ZIncrBy(ctx, "demo:rank", 50, "bob")
|
||||
rdb.ZIncrBy(ctx, "demo:rank", 10, "alice")
|
||||
top, _ := rdb.ZRevRangeWithScores(ctx, "demo:rank", 0, 9).Result()
|
||||
for i, z := range top {
|
||||
fmt.Printf("第 %d 名 %v %.0f 分\n", i+1, z.Member, z.Score)
|
||||
}
|
||||
|
||||
// 对象用 Hash
|
||||
rdb.HSet(ctx, "demo:user:7", map[string]any{"name": "张三", "level": 3})
|
||||
u, _ := rdb.HGetAll(ctx, "demo:user:7").Result()
|
||||
fmt.Println(u["name"], u["level"])
|
||||
|
||||
rdb.Del(ctx, "demo:views:42", "demo:rank", "demo:user:7")
|
||||
}
|
||||
```
|
||||
|
||||
## 易错点
|
||||
|
||||
- **大 key**:一个 Hash / ZSet 里放几百万元素,`HGETALL`、`DEL` 会阻塞 Redis。拆分 key,删除用 `UNLINK`。
|
||||
- **`KEYS *`**:线上会阻塞,用 `SCAN` 分批遍历。
|
||||
- **忘记设过期时间**:缓存类 key 一律带 TTL,否则内存只增不减。
|
||||
- **用 List 做可靠队列**:`RPOP` 后消费者崩溃,消息就丢了;需要可靠性用 Stream(消费组 + ACK)或专业 MQ。
|
||||
- **把 Redis 当主存储**:持久化有丢数据窗口,重要数据以数据库为准。
|
||||
|
||||
## 面试常问
|
||||
|
||||
见 [Redis 面试题](interview.md):Redis 为什么快、有哪些数据结构和场景、过期和淘汰策略、持久化方式。
|
||||
@@ -0,0 +1,176 @@
|
||||
---
|
||||
id: backend.redis.cache-patterns
|
||||
title: 缓存模式:旁路缓存、穿透 / 击穿 / 雪崩、一致性
|
||||
type: lesson
|
||||
domain: backend
|
||||
stack: [redis]
|
||||
tags: [旁路缓存, 缓存穿透, 缓存击穿, 缓存雪崩, 一致性, singleflight]
|
||||
level: intermediate
|
||||
prerequisites: [backend.redis.data-structures]
|
||||
est_hours: 3
|
||||
related: [backend.redis.lock-ratelimit, backend.redis.interview]
|
||||
week: [3, 6]
|
||||
order: 2
|
||||
---
|
||||
|
||||
# 缓存模式:旁路缓存、穿透 / 击穿 / 雪崩、一致性
|
||||
|
||||
## 解释说明
|
||||
|
||||
**旁路缓存(Cache Aside)**——最常用:
|
||||
|
||||
- 读:先读缓存,命中直接返回;未命中读数据库,写入缓存(带过期时间)再返回。
|
||||
- 写:**先更新数据库,再删除缓存**(不是更新缓存)。下一次读自然会加载新值。
|
||||
|
||||
为什么删除而不是更新缓存:并发写时两个请求更新缓存的顺序可能和更新数据库的顺序不一致,导致缓存里留下旧值;删除更简单,也避免为不常读的数据计算缓存。
|
||||
|
||||
**三个经典问题**
|
||||
|
||||
| 问题 | 现象 | 解决 |
|
||||
| --- | --- | --- |
|
||||
| 穿透 | 查询**不存在**的数据,每次都打到数据库(常见于恶意请求) | 缓存空值(短 TTL);参数校验;布隆过滤器 |
|
||||
| 击穿 | 一个**热点 key** 过期瞬间,大量请求同时查库 | 同一个 key 只让一个请求回源(singleflight / 互斥锁);热点 key 逻辑过期 |
|
||||
| 雪崩 | **大量 key 同时过期**或 Redis 宕机,请求全部压到数据库 | 过期时间加随机值;Redis 高可用;限流降级 |
|
||||
|
||||
**一致性**:“先更新库再删缓存”仍有极小概率不一致(读请求在删除前读到旧值并在删除后写回)。常见补充:延迟双删(更新后过一会儿再删一次)、订阅 binlog 异步删除缓存、给缓存设较短 TTL 兜底。缓存只能做到**最终一致**,强一致需求(如余额)不要读缓存。
|
||||
|
||||
## 案例
|
||||
|
||||
商品详情页 QPS 高,数据库扛不住:
|
||||
|
||||
- 详情缓存 10 分钟 + 0~60 秒随机值,防止同时过期。
|
||||
- 不存在的商品 ID 缓存空值 1 分钟,防穿透。
|
||||
- 热门商品过期时用 singleflight 合并回源请求,防击穿。
|
||||
- 后台修改商品后删除缓存。
|
||||
|
||||
## 代码示例
|
||||
|
||||
旁路缓存 + 空值缓存 + singleflight(`golang.org/x/sync/singleflight` 合并同一进程内的并发回源):
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/rand/v2"
|
||||
"os"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
"golang.org/x/sync/singleflight"
|
||||
)
|
||||
|
||||
type Product struct {
|
||||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Price int64 `json:"price"`
|
||||
}
|
||||
|
||||
var ErrNotFound = errors.New("商品不存在")
|
||||
|
||||
const nullValue = "null" // 空值标记,防穿透
|
||||
|
||||
type ProductCache struct {
|
||||
rdb *redis.Client
|
||||
group singleflight.Group
|
||||
load func(ctx context.Context, id int64) (*Product, error) // 查数据库
|
||||
}
|
||||
|
||||
func (c *ProductCache) Get(ctx context.Context, id int64) (*Product, error) {
|
||||
key := fmt.Sprintf("product:%d", id)
|
||||
s, err := c.rdb.Get(ctx, key).Result()
|
||||
if err == nil {
|
||||
if s == nullValue {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
var p Product
|
||||
if err := json.Unmarshal([]byte(s), &p); err == nil {
|
||||
return &p, nil
|
||||
}
|
||||
} else if !errors.Is(err, redis.Nil) {
|
||||
// Redis 出错时降级直接查库(也可以选择返回错误,看业务)
|
||||
return c.load(ctx, id)
|
||||
}
|
||||
// 未命中:同一个 key 的并发请求只有一个去查库
|
||||
v, err, _ := c.group.Do(key, func() (any, error) {
|
||||
p, err := c.load(ctx, id)
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
c.rdb.Set(ctx, key, nullValue, time.Minute)
|
||||
return nil, err
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
b, _ := json.Marshal(p)
|
||||
ttl := 10*time.Minute + time.Duration(rand.IntN(60))*time.Second // 随机过期,防雪崩
|
||||
c.rdb.Set(ctx, key, b, ttl)
|
||||
return p, nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v.(*Product), nil
|
||||
}
|
||||
|
||||
// Update:先更新数据库,再删除缓存
|
||||
func (c *ProductCache) Update(ctx context.Context, p *Product, save func(*Product) error) error {
|
||||
if err := save(p); err != nil {
|
||||
return err
|
||||
}
|
||||
return c.rdb.Del(ctx, fmt.Sprintf("product:%d", p.ID)).Err()
|
||||
}
|
||||
|
||||
func main() {
|
||||
url := os.Getenv("REDIS_URL")
|
||||
if url == "" {
|
||||
fmt.Println("未设置 REDIS_URL,跳过")
|
||||
return
|
||||
}
|
||||
opt, _ := redis.ParseURL(url)
|
||||
rdb := redis.NewClient(opt)
|
||||
defer rdb.Close()
|
||||
ctx := context.Background()
|
||||
rdb.Del(ctx, "product:1", "product:404")
|
||||
|
||||
var dbHits atomic.Int32
|
||||
c := &ProductCache{rdb: rdb, load: func(ctx context.Context, id int64) (*Product, error) {
|
||||
dbHits.Add(1)
|
||||
time.Sleep(50 * time.Millisecond) // 模拟慢查询
|
||||
if id == 404 {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return &Product{ID: id, Name: "键盘", Price: 19900}, nil
|
||||
}}
|
||||
|
||||
var wg sync.WaitGroup
|
||||
for range 100 { // 100 个并发请求同一个未缓存的商品
|
||||
wg.Add(1)
|
||||
go func() { defer wg.Done(); _, _ = c.Get(ctx, 1) }()
|
||||
}
|
||||
wg.Wait()
|
||||
fmt.Println("100 个并发请求,查库次数:", dbHits.Load()) // 1
|
||||
|
||||
_, err := c.Get(ctx, 404)
|
||||
_, err2 := c.Get(ctx, 404)
|
||||
fmt.Println(err, err2, "查库次数:", dbHits.Load()) // 第二次命中空值缓存,仍是 2
|
||||
rdb.Del(ctx, "product:1", "product:404")
|
||||
}
|
||||
```
|
||||
|
||||
## 易错点
|
||||
|
||||
- **先删缓存再更新数据库**:删除后、更新前有读请求进来,会把旧值重新写进缓存,不一致窗口更大。
|
||||
- **更新数据库后更新缓存**:并发写时可能写入旧值;且很多数据写多读少,白白计算。
|
||||
- **空值缓存 TTL 太长**:数据后来被创建了,用户仍然看到“不存在”。
|
||||
- **singleflight 只在单个进程内生效**:多实例部署时每个实例仍会各回源一次,一般可以接受;需要全局只回源一次时用分布式锁。
|
||||
- **缓存序列化格式变了**:新版本读不了旧缓存,key 带版本号(如 `product:v2:1`)。
|
||||
- **所有接口都上缓存**:缓存带来一致性问题,只给读多写少、能接受短暂旧数据的接口加。
|
||||
|
||||
## 面试常问
|
||||
|
||||
见 [Redis 面试题](interview.md):穿透 / 击穿 / 雪崩、缓存和数据库一致性、为什么删缓存而不是更新缓存。
|
||||
@@ -0,0 +1,117 @@
|
||||
---
|
||||
id: backend.redis.lock-ratelimit
|
||||
title: 分布式锁和限流:SET NX、Lua、令牌释放、固定窗口与滑动窗口
|
||||
type: lesson
|
||||
domain: backend
|
||||
stack: [redis]
|
||||
tags: [分布式锁, Lua, 限流, 滑动窗口, 令牌桶]
|
||||
level: intermediate
|
||||
prerequisites: [backend.redis.data-structures]
|
||||
est_hours: 3
|
||||
related: [backend.redis.scenario.stock-reservation, backend.redis.interview, backend.gin.middleware-auth]
|
||||
week: [3, 14]
|
||||
order: 3
|
||||
---
|
||||
|
||||
# 分布式锁和限流:SET NX、Lua、令牌释放、固定窗口与滑动窗口
|
||||
|
||||
## 解释说明
|
||||
|
||||
**分布式锁**:多个服务实例之间互斥,例如“同一时间只有一个实例执行定时任务”“同一个订单只处理一次回调”。
|
||||
|
||||
- 加锁:`SET lock:key <随机令牌> NX PX 30000`。`NX` 保证只有一个人能设置成功,`PX` 设置过期时间防止持有者崩溃后锁永远不释放。**加锁和设置过期必须是一条命令**(不要 `SETNX` 再 `EXPIRE`)。
|
||||
- 解锁:用 Lua 脚本“GET 比较令牌 → 相等才 DEL”,保证只删自己的锁。直接 `DEL` 可能删掉别人的锁:自己执行超时、锁已过期被别人拿到后,再 `DEL` 就把别人的锁删了。
|
||||
- 过期时间怎么定:大于业务最长执行时间;执行时间不确定时由后台协程定期续期(Redisson 的“看门狗”就是这个思路)。
|
||||
- 局限:Redis 主从切换时锁可能丢失。对正确性要求极高的场景,用数据库唯一约束 / 乐观锁兜底,或者在资源侧校验“防护令牌”(递增的版本号)。
|
||||
|
||||
**限流算法**
|
||||
|
||||
| 算法 | 思路 | 特点 |
|
||||
| --- | --- | --- |
|
||||
| 固定窗口 | `INCR rl:user:1:202610231530`,首次设置 60 秒过期,超过阈值拒绝 | 最简单;窗口交界处可能瞬间放过 2 倍流量 |
|
||||
| 滑动窗口 | ZSET 存每次请求时间,删掉窗口外的再计数 | 精确;每次请求占一个元素,内存随请求量增长 |
|
||||
| 令牌桶 | 按固定速率放令牌,请求取令牌,允许一定突发 | 平滑且允许突发;实现稍复杂 |
|
||||
| 漏桶 | 请求进队列,按固定速率处理 | 输出最平滑,不允许突发 |
|
||||
|
||||
单实例服务用进程内限流就够(Go 的 `golang.org/x/time/rate` 是令牌桶);多实例要共享计数时才用 Redis。
|
||||
|
||||
**为什么用 Lua**:多条命令(判断 + 修改)需要原子执行。Redis 执行 Lua 脚本期间不会执行其他命令,所以脚本要短小,不能有耗时循环。
|
||||
|
||||
## 案例
|
||||
|
||||
- 支付回调可能重复到达:处理前 `TryLock("lock:pay-callback:" + orderID, 30s)`,拿不到锁直接返回“处理中”;真正的幂等仍由数据库状态和唯一约束保证。
|
||||
- 登录接口防暴力破解:同一 IP 每分钟最多 10 次、同一账号每小时最多 20 次,用滑动窗口。
|
||||
- 调用大模型 API:按租户限流,避免某个租户把额度用光。
|
||||
|
||||
## 代码示例
|
||||
|
||||
完整代码和测试在 [examples/stock-lock-ratelimit](examples/stock-lock-ratelimit/)(`lock.go`、`ratelimit.go`),下面是核心片段:
|
||||
|
||||
```go
|
||||
// 只有令牌一致才删除,防止误删别人的锁
|
||||
var unlockScript = redis.NewScript(`
|
||||
if redis.call("GET", KEYS[1]) == ARGV[1] then
|
||||
return redis.call("DEL", KEYS[1])
|
||||
end
|
||||
return 0`)
|
||||
|
||||
func TryLock(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration) (*Lock, error) {
|
||||
token := randomToken()
|
||||
ok, err := rdb.SetNX(ctx, key, token, ttl).Result() // SET key token NX PX ttl
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !ok {
|
||||
return nil, ErrLockNotAcquired
|
||||
}
|
||||
return &Lock{rdb: rdb, key: key, token: token}, nil
|
||||
}
|
||||
```
|
||||
|
||||
滑动窗口限流脚本:
|
||||
|
||||
```lua
|
||||
local key, now, window, limit, member = KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3]), ARGV[4]
|
||||
redis.call("ZREMRANGEBYSCORE", key, 0, now - window) -- 删掉窗口外的请求
|
||||
if redis.call("ZCARD", key) >= limit then
|
||||
return 0 -- 超限
|
||||
end
|
||||
redis.call("ZADD", key, now, member)
|
||||
redis.call("PEXPIRE", key, window)
|
||||
return 1
|
||||
```
|
||||
|
||||
在 Gin 里接成中间件(示意):
|
||||
|
||||
```go
|
||||
func RateLimit(sw *stocklock.SlidingWindow) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
ok, err := sw.Allow(c.Request.Context(), "rl:ip:"+c.ClientIP(), time.Now())
|
||||
if err != nil { // Redis 故障时放行还是拒绝,要按业务决定(这里选择放行并记录日志)
|
||||
log.Printf("限流检查失败:%v", err)
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
if !ok {
|
||||
c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{"code": 42900, "message": "请求太频繁,请稍后再试"})
|
||||
return
|
||||
}
|
||||
c.Next()
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
测试里验证了:锁不能被重复获取;锁过期后旧持有者解锁不会删掉新持有者的锁;滑动窗口限 3 次时第 4、5 次被拒,窗口滑过后放行。
|
||||
|
||||
## 易错点
|
||||
|
||||
- **`SETNX` 和 `EXPIRE` 分两条命令**:中间崩溃就留下永不过期的锁。
|
||||
- **解锁直接 `DEL`**:可能删掉别人的锁。
|
||||
- **锁的过期时间小于业务执行时间**:两个实例同时执行。要么设足够长,要么续期,并且业务本身做幂等。
|
||||
- **把分布式锁当成唯一的正确性保证**:网络分区、GC 停顿、主从切换都可能导致锁失效,关键数据要有数据库层面的约束兜底。
|
||||
- **限流 key 没有过期时间**:key 越来越多。
|
||||
- **按 `X-Forwarded-For` 限流却没配置可信代理**:客户端可以伪造 IP 绕过(Gin 用 `SetTrustedProxies` 配置)。
|
||||
|
||||
## 面试常问
|
||||
|
||||
见 [Redis 面试题](interview.md):分布式锁怎么实现、为什么要用 Lua、锁过期了业务还没执行完怎么办、几种限流算法的区别。
|
||||
@@ -0,0 +1,11 @@
|
||||
module example/stocklock
|
||||
|
||||
go 1.26.0
|
||||
|
||||
require github.com/redis/go-redis/v9 v9.23.0
|
||||
|
||||
require (
|
||||
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
||||
go.uber.org/atomic v1.12.0 // indirect
|
||||
golang.org/x/sys v0.48.0 // indirect
|
||||
)
|
||||
@@ -0,0 +1,20 @@
|
||||
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
|
||||
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
|
||||
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
|
||||
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
|
||||
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
|
||||
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
|
||||
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
|
||||
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
|
||||
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
|
||||
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
|
||||
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
|
||||
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
|
||||
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
|
||||
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
|
||||
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
|
||||
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
|
||||
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
|
||||
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
|
||||
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
@@ -0,0 +1,50 @@
|
||||
// Package stocklock 演示 Redis 的三个高频用法:分布式锁、滑动窗口限流、库存预扣。
|
||||
package stocklock
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var ErrLockNotAcquired = errors.New("没有拿到锁")
|
||||
|
||||
// 只有持有者(令牌一致)才能释放,防止误删别人的锁
|
||||
var unlockScript = redis.NewScript(`
|
||||
if redis.call("GET", KEYS[1]) == ARGV[1] then
|
||||
return redis.call("DEL", KEYS[1])
|
||||
end
|
||||
return 0`)
|
||||
|
||||
type Lock struct {
|
||||
rdb *redis.Client
|
||||
key string
|
||||
token string
|
||||
}
|
||||
|
||||
// TryLock 用 SET key token NX PX ttl 加锁。ttl 必须大于业务最长执行时间(或者自己续期)。
|
||||
func TryLock(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration) (*Lock, error) {
|
||||
b := make([]byte, 16)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
token := hex.EncodeToString(b)
|
||||
ok, err := rdb.SetNX(ctx, key, token, ttl).Result()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !ok {
|
||||
return nil, ErrLockNotAcquired
|
||||
}
|
||||
return &Lock{rdb: rdb, key: key, token: token}, nil
|
||||
}
|
||||
|
||||
// Unlock 返回 false 表示锁已经过期或被别人持有(说明业务执行超过了 ttl,需要排查)
|
||||
func (l *Lock) Unlock(ctx context.Context) (bool, error) {
|
||||
n, err := unlockScript.Run(ctx, l.rdb, []string{l.key}, l.token).Int()
|
||||
return n == 1, err
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package stocklock
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// 滑动窗口:ZSET 里存每次请求的时间戳(毫秒),先删掉窗口外的,再数窗口内的
|
||||
var slidingScript = redis.NewScript(`
|
||||
local key, now, window, limit, member = KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3]), ARGV[4]
|
||||
redis.call("ZREMRANGEBYSCORE", key, 0, now - window)
|
||||
if redis.call("ZCARD", key) >= limit then
|
||||
return 0
|
||||
end
|
||||
redis.call("ZADD", key, now, member)
|
||||
redis.call("PEXPIRE", key, window)
|
||||
return 1`)
|
||||
|
||||
type SlidingWindow struct {
|
||||
rdb *redis.Client
|
||||
limit int
|
||||
window time.Duration
|
||||
seq func() string // 生成唯一成员,避免同一毫秒的请求互相覆盖
|
||||
}
|
||||
|
||||
func NewSlidingWindow(rdb *redis.Client, limit int, window time.Duration) *SlidingWindow {
|
||||
var n atomic.Uint64 // 并发安全的序号;多实例部署时成员里再加上实例标识或用 UUID
|
||||
return &SlidingWindow{rdb: rdb, limit: limit, window: window, seq: func() string {
|
||||
return fmt.Sprintf("%d-%d", time.Now().UnixNano(), n.Add(1))
|
||||
}}
|
||||
}
|
||||
|
||||
// Allow 判断 key(如 "rl:user:42")在当前窗口内是否还能通过
|
||||
func (s *SlidingWindow) Allow(ctx context.Context, key string, now time.Time) (bool, error) {
|
||||
n, err := slidingScript.Run(ctx, s.rdb, []string{key},
|
||||
now.UnixMilli(), s.window.Milliseconds(), s.limit, s.seq()).Int()
|
||||
return n == 1, err
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
package stocklock
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrSoldOut = errors.New("库存不足")
|
||||
ErrDuplicate = errors.New("每人限购一件,已经抢过了")
|
||||
)
|
||||
|
||||
// 原子地:检查是否已购买 → 检查库存 → 扣库存 → 记录用户
|
||||
var reserveScript = redis.NewScript(`
|
||||
if redis.call("SISMEMBER", KEYS[2], ARGV[1]) == 1 then
|
||||
return -2
|
||||
end
|
||||
local left = tonumber(redis.call("GET", KEYS[1]) or "0")
|
||||
if left <= 0 then
|
||||
return -1
|
||||
end
|
||||
redis.call("DECR", KEYS[1])
|
||||
redis.call("SADD", KEYS[2], ARGV[1])
|
||||
return left - 1`)
|
||||
|
||||
// Reserve 预扣库存。成功后应把订单消息发到 MQ,由消费者异步落库。
|
||||
func Reserve(ctx context.Context, rdb *redis.Client, sku, userID string) (left int, err error) {
|
||||
n, err := reserveScript.Run(ctx, rdb, []string{"stock:" + sku, "stock:" + sku + ":buyers"}, userID).Int()
|
||||
switch {
|
||||
case err != nil:
|
||||
return 0, err
|
||||
case n == -1:
|
||||
return 0, ErrSoldOut
|
||||
case n == -2:
|
||||
return 0, ErrDuplicate
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
package stocklock
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// 需要 Redis:REDIS_URL=redis://localhost:6379/0 go test ./...
|
||||
func client(t *testing.T) (*redis.Client, string) {
|
||||
t.Helper()
|
||||
url := os.Getenv("REDIS_URL")
|
||||
if url == "" {
|
||||
t.Skip("未设置 REDIS_URL,跳过集成测试")
|
||||
}
|
||||
opt, err := redis.ParseURL(url)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rdb := redis.NewClient(opt)
|
||||
prefix := fmt.Sprintf("test:%d:", time.Now().UnixNano())
|
||||
t.Cleanup(func() {
|
||||
ctx := context.Background()
|
||||
iter := rdb.Scan(ctx, 0, prefix+"*", 100).Iterator()
|
||||
for iter.Next(ctx) {
|
||||
rdb.Del(ctx, iter.Val())
|
||||
}
|
||||
rdb.Close()
|
||||
})
|
||||
return rdb, prefix
|
||||
}
|
||||
|
||||
func TestLock(t *testing.T) {
|
||||
rdb, p := client(t)
|
||||
ctx := context.Background()
|
||||
l1, err := TryLock(ctx, rdb, p+"lock", 200*time.Millisecond)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := TryLock(ctx, rdb, p+"lock", time.Second); !errors.Is(err, ErrLockNotAcquired) {
|
||||
t.Fatalf("锁被重复获取:%v", err)
|
||||
}
|
||||
time.Sleep(300 * time.Millisecond) // 锁过期,别人拿到锁
|
||||
l2, err := TryLock(ctx, rdb, p+"lock", time.Second)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, _ := l1.Unlock(ctx); ok {
|
||||
t.Fatal("过期的旧持有者不应该删掉新持有者的锁")
|
||||
}
|
||||
if ok, _ := l2.Unlock(ctx); !ok {
|
||||
t.Fatal("持有者应该能释放锁")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSlidingWindow(t *testing.T) {
|
||||
rdb, p := client(t)
|
||||
ctx := context.Background()
|
||||
sw := NewSlidingWindow(rdb, 3, time.Second)
|
||||
now := time.Now()
|
||||
var got []bool
|
||||
for i := range 5 {
|
||||
ok, err := sw.Allow(ctx, p+"rl", now.Add(time.Duration(i)*10*time.Millisecond))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got = append(got, ok)
|
||||
}
|
||||
if fmt.Sprint(got) != "[true true true false false]" {
|
||||
t.Fatalf("窗口内限 3 次,得到 %v", got)
|
||||
}
|
||||
// 1.1 秒后前面的请求滑出窗口
|
||||
if ok, _ := sw.Allow(ctx, p+"rl", now.Add(1100*time.Millisecond)); !ok {
|
||||
t.Fatal("窗口滑过后应该放行")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReserveNoOversell(t *testing.T) {
|
||||
rdb, p := client(t)
|
||||
ctx := context.Background()
|
||||
sku := p + "sku1"
|
||||
rdb.Set(ctx, "stock:"+sku, 10, 0)
|
||||
t.Cleanup(func() { rdb.Del(ctx, "stock:"+sku, "stock:"+sku+":buyers") })
|
||||
|
||||
var success, soldOut, dup atomic.Int32
|
||||
var wg sync.WaitGroup
|
||||
for i := range 100 { // 100 个用户抢 10 件
|
||||
for range 2 { // 每个用户重复点两次
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
_, err := Reserve(ctx, rdb, sku, fmt.Sprint("u", i))
|
||||
switch {
|
||||
case err == nil:
|
||||
success.Add(1)
|
||||
case errors.Is(err, ErrSoldOut):
|
||||
soldOut.Add(1)
|
||||
case errors.Is(err, ErrDuplicate):
|
||||
dup.Add(1)
|
||||
default:
|
||||
t.Error(err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
}
|
||||
wg.Wait()
|
||||
left, _ := rdb.Get(ctx, "stock:"+sku).Int()
|
||||
buyers, _ := rdb.SCard(ctx, "stock:"+sku+":buyers").Result()
|
||||
if success.Load() != 10 || left != 0 || buyers != 10 {
|
||||
t.Fatalf("成功 %d,剩余 %d,购买人数 %d", success.Load(), left, buyers)
|
||||
}
|
||||
t.Logf("成功 %d,售罄 %d,重复 %d", success.Load(), soldOut.Load(), dup.Load())
|
||||
}
|
||||
@@ -4,12 +4,40 @@ title: Redis
|
||||
type: index
|
||||
domain: backend
|
||||
stack: [redis]
|
||||
tags: []
|
||||
tags: [缓存, Redis, 分布式锁, 限流]
|
||||
week: [3, 6, 14]
|
||||
---
|
||||
|
||||
# Redis
|
||||
|
||||
数据结构、缓存模式、分布式锁、限流、Streams。
|
||||
内存数据库,后端面试必考:缓存、计数、排行榜、分布式锁、限流、简单队列。本计划在项目一里做缓存和限流(第 3 周),在 RAG 服务里缓存检索结果(第 6 周),第 14 周补齐高并发相关题目。
|
||||
|
||||
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
|
||||
## 学习路线
|
||||
|
||||
| 顺序 | 课程 | 级别 | 预计 |
|
||||
| --- | --- | --- | --- |
|
||||
| 1 | [数据结构和常用命令:String、Hash、List、Set、ZSet、Stream](01-data-structures.md) | 基础 | 2 小时 |
|
||||
| 2 | [缓存模式:旁路缓存、穿透 / 击穿 / 雪崩、一致性](02-cache-patterns.md) | 进阶 | 3 小时 |
|
||||
| 3 | [分布式锁和限流:SET NX、Lua、令牌释放、固定窗口与滑动窗口](03-lock-ratelimit.md) | 进阶 | 3 小时 |
|
||||
|
||||
## 企业场景
|
||||
|
||||
- [抢购库存预扣:Lua 原子扣减、防重复下单、异步落库](scenarios/stock-reservation.md)
|
||||
|
||||
## 面试题
|
||||
|
||||
- [Redis 面试题](interview.md)
|
||||
|
||||
## 示例代码
|
||||
|
||||
- [examples/stock-lock-ratelimit](examples/stock-lock-ratelimit/):Go + go-redis 实现库存预扣、分布式锁、滑动窗口限流;设置 `REDIS_URL` 后运行集成测试
|
||||
|
||||
## 在 16 周计划中
|
||||
|
||||
- [第 3 周:项目一(缓存、限流)](../../../plan/week03-project1.md)、[第 6 周:RAG 服务缓存](../../../plan/week06-rag-2.md)、[第 14 周:后端扩展](../../../plan/week14-backend-extend-deploy.md)
|
||||
|
||||
## 官方资料
|
||||
|
||||
- Redis 文档:https://redis.io/docs/latest/
|
||||
- 命令参考:https://redis.io/docs/latest/commands/
|
||||
- go-redis:https://redis.uptrace.dev/
|
||||
@@ -0,0 +1,65 @@
|
||||
---
|
||||
id: backend.redis.interview
|
||||
title: Redis 面试题
|
||||
type: interview
|
||||
domain: backend
|
||||
stack: [redis]
|
||||
tags: [Redis, 缓存, 分布式锁, 面试]
|
||||
level: intermediate
|
||||
related: [backend.redis.data-structures, backend.redis.cache-patterns, backend.redis.lock-ratelimit]
|
||||
week: [3, 14, 16]
|
||||
---
|
||||
|
||||
# Redis 面试题
|
||||
|
||||
## 基础
|
||||
|
||||
### 【基础】Redis 为什么快?
|
||||
|
||||
**参考答案**:数据在内存里;核心命令执行是单线程的,没有锁竞争和线程切换;使用 IO 多路复用(epoll)同时处理大量连接;数据结构针对场景做了优化(如压缩列表、跳表)。Redis 6 起网络读写可以多线程,命令执行仍是单线程。
|
||||
|
||||
### 【基础】Redis 有哪些数据类型?各举一个使用场景。
|
||||
|
||||
**参考答案**:String(缓存、计数器、验证码)、Hash(对象、购物车)、List(最新消息列表)、Set(标签、去重、共同关注)、ZSet(排行榜、延迟队列)、Stream(轻量消息队列);另有 Bitmap(签到)、HyperLogLog(UV 统计)、Geo(附近的人)。
|
||||
|
||||
### 【基础】过期的 key 是怎么删除的?内存满了怎么办?
|
||||
|
||||
**参考答案**:惰性删除(访问时发现过期就删)+ 定期删除(周期性抽样检查过期 key)。内存达到 `maxmemory` 时按淘汰策略处理:`noeviction`(拒绝写入)、`allkeys-lru`、`allkeys-lfu`、`volatile-lru`(只淘汰设置了过期的 key)等,缓存场景常用 `allkeys-lru` / `allkeys-lfu`。
|
||||
|
||||
### 【基础】RDB 和 AOF 的区别?
|
||||
|
||||
**参考答案**:RDB 定时生成内存快照,文件小、恢复快,但可能丢失最后一次快照之后的数据;AOF 追加记录写命令,可配置每秒刷盘,丢数据更少,但文件更大,需要重写压缩。生产常两者都开,Redis 4 起支持混合持久化。
|
||||
|
||||
## 进阶
|
||||
|
||||
### 【进阶】缓存穿透、击穿、雪崩分别是什么?怎么解决?
|
||||
|
||||
**参考答案**:穿透是查询不存在的数据,每次都打到数据库——缓存空值、参数校验、布隆过滤器。击穿是热点 key 过期瞬间大量请求同时回源——互斥锁 / singleflight 只让一个请求回源,或逻辑过期后台刷新。雪崩是大量 key 同时过期或 Redis 不可用——过期时间加随机值、Redis 高可用、服务限流降级。
|
||||
|
||||
### 【进阶】怎么保证缓存和数据库的一致性?
|
||||
|
||||
**参考答案**:常用旁路缓存:先更新数据库,再删除缓存。删除而不是更新,是为了避免并发写导致缓存写入旧值。仍有极小概率不一致,可以用延迟双删、订阅 binlog 异步删除、短 TTL 兜底。缓存只能做到最终一致,要求强一致的数据(余额、库存最终值)以数据库为准。
|
||||
|
||||
**追问**:为什么不先删缓存再更新数据库?→ 删除后、更新前的读请求会把旧值写回缓存,不一致窗口更大。
|
||||
|
||||
### 【进阶】Redis 分布式锁怎么实现?有什么问题?
|
||||
|
||||
**参考答案**:`SET key 随机令牌 NX PX 过期时间` 加锁;用 Lua 脚本比较令牌后删除来解锁,防止误删别人的锁。问题:业务执行时间超过过期时间会导致两个持有者同时存在(续期 / 看门狗);主从异步复制,主节点宕机时锁可能丢失(Redlock 有争议);所以关键业务还要用数据库唯一约束、乐观锁等做最终保证。
|
||||
|
||||
### 【进阶】Redis 的主从、哨兵、集群分别解决什么问题?
|
||||
|
||||
**参考答案**:主从复制解决读扩展和数据冗余;哨兵(Sentinel)监控主节点,故障时自动选新主,解决高可用;Cluster 把数据按 16384 个槽分到多个主节点,解决容量和写扩展,每个主节点也可以有从节点。Cluster 下多 key 操作(包括 Lua)要求 key 在同一个槽,可以用哈希标签 `{}`。
|
||||
|
||||
## 场景题
|
||||
|
||||
### 【场景题】秒杀场景怎么防止超卖和重复购买?
|
||||
|
||||
**参考答案**:库存提前加载到 Redis;Lua 脚本原子完成“是否已购买 → 库存是否充足 → 扣减 → 记录用户”;成功后发 MQ 异步创建订单,数据库唯一约束兜底;失败或超时未支付回补库存;前端、网关层层限流。详见[库存预扣场景](scenarios/stock-reservation.md)。
|
||||
|
||||
### 【场景题】线上 Redis 突然变慢,怎么排查?
|
||||
|
||||
**参考答案**:`SLOWLOG GET` 看慢命令(`KEYS *`、大 key 的 `HGETALL` / `DEL`、复杂 Lua);`INFO` 看内存、连接数、命中率、是否在做 RDB / AOF 重写(fork 导致的卡顿);`--bigkeys` / `MEMORY USAGE` 找大 key;检查是否有热点 key 集中在一个节点。处理:改用 `SCAN`、`UNLINK`,拆分大 key,热点 key 加本地缓存。
|
||||
|
||||
### 【场景题】一个接口要按用户限流,每分钟最多 60 次,多实例部署,怎么做?
|
||||
|
||||
**参考答案**:用 Redis 共享计数。简单做法是固定窗口 `INCR` + 过期时间;要求精确时用 ZSET 滑动窗口(Lua 脚本里删除过期记录、计数、写入);允许突发用令牌桶。返回 429 并带上重试时间。要考虑 Redis 故障时的策略(放行还是拒绝)。详见[分布式锁和限流](03-lock-ratelimit.md)。
|
||||
@@ -0,0 +1,85 @@
|
||||
---
|
||||
id: backend.redis.scenario.stock-reservation
|
||||
title: 抢购库存预扣:Lua 原子扣减、防重复下单、异步落库
|
||||
type: scenario
|
||||
domain: backend
|
||||
stack: [redis, mq, mysql]
|
||||
tags: [秒杀, 库存, Lua, 防超卖, 削峰]
|
||||
level: advanced
|
||||
prerequisites: [backend.redis.lock-ratelimit]
|
||||
est_hours: 3
|
||||
related: [backend.redis.lock-ratelimit, backend.mq.reliability, backend.redis.interview]
|
||||
week: [14]
|
||||
---
|
||||
|
||||
# 抢购库存预扣:Lua 原子扣减、防重复下单、异步落库
|
||||
|
||||
## 业务背景与问题
|
||||
|
||||
电商的限时抢购活动:100 件商品,开抢瞬间几万个请求。之前直接在数据库里 `UPDATE stock SET num = num - 1 WHERE num > 0`,结果数据库行锁排队、连接池被占满,连带其他业务一起变慢;还出现过同一个用户买了多件。
|
||||
|
||||
## 约束
|
||||
|
||||
- 绝对不能超卖;每人限购 1 件。
|
||||
- 抢购接口要快速返回结果(成功进入下单 / 已抢光)。
|
||||
- 数据库是最终的数据来源,Redis 可能丢数据。
|
||||
- 不能影响其他业务。
|
||||
|
||||
## 方案设计
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
U[用户] --> N[Nginx / 网关限流] --> A[抢购接口]
|
||||
A -->|Lua 原子预扣| R[(Redis 库存 + 已购用户)]
|
||||
A -->|预扣成功:发消息| Q[[消息队列]]
|
||||
Q --> C[下单消费者] -->|事务:建订单 + 扣数据库库存| D[(MySQL)]
|
||||
C -->|失败:回补 Redis 库存| R
|
||||
```
|
||||
|
||||
1. **层层削峰**:前端按钮防重复点击、网关按用户 / IP 限流、活动未开始直接拒绝。
|
||||
2. **Redis 预扣**:活动开始前把库存加载到 Redis;Lua 脚本原子执行“是否已购买 → 库存是否大于 0 → 扣减 → 记录用户”。
|
||||
3. **异步下单**:预扣成功后发消息到 MQ,接口立即返回“抢购成功,订单生成中”;消费者按数据库能承受的速度建订单,用数据库唯一约束 `(活动ID, 用户ID)` 兜底防重复。
|
||||
4. **对账和回补**:下单失败或超时未支付时回补 Redis 库存;定时对账 Redis 和数据库的库存。
|
||||
|
||||
## 关键代码
|
||||
|
||||
完整代码和并发测试见 [examples/stock-lock-ratelimit](../examples/stock-lock-ratelimit/)(`stock.go`):
|
||||
|
||||
```lua
|
||||
-- KEYS[1] = 库存,KEYS[2] = 已购用户集合,ARGV[1] = 用户 ID
|
||||
if redis.call("SISMEMBER", KEYS[2], ARGV[1]) == 1 then
|
||||
return -2 -- 已经买过
|
||||
end
|
||||
local left = tonumber(redis.call("GET", KEYS[1]) or "0")
|
||||
if left <= 0 then
|
||||
return -1 -- 售罄
|
||||
end
|
||||
redis.call("DECR", KEYS[1])
|
||||
redis.call("SADD", KEYS[2], ARGV[1])
|
||||
return left - 1
|
||||
```
|
||||
|
||||
测试:100 个用户各点两次、共 200 个并发请求抢 10 件,结果固定是成功 10 次、剩余库存 0、购买人数 10。
|
||||
|
||||
## 取舍
|
||||
|
||||
| 方案 | 优点 | 缺点 |
|
||||
| --- | --- | --- |
|
||||
| 数据库条件更新 | 简单、强一致 | 高并发下行锁排队,拖垮数据库 |
|
||||
| **Redis Lua 预扣 + MQ 异步下单** | 扛高并发、保护数据库 | 链路长,要处理 Redis 与数据库不一致、消息丢失 |
|
||||
| Redis `DECR` 后判断负数再 `INCR` 回去 | 不用 Lua | 不好同时做限购;有短暂负数 |
|
||||
| 分布式锁包住“查 + 扣” | 好理解 | 所有请求串行抢锁,吞吐很低 |
|
||||
|
||||
## 易错点
|
||||
|
||||
- 先 `GET` 判断再 `DECR`(不是原子的)→ 超卖。
|
||||
- 预扣成功但消息发送失败 → 库存少了但没有订单。处理:发送失败时回补库存,或者使用可靠消息(见[消息可靠性](../../mq/03-reliability.md))。
|
||||
- 消费者重复消费 → 重复建单。用唯一约束和幂等处理。
|
||||
- 用户抢到后不支付 → 超时取消订单并回补库存(延迟消息,见 MQ 专题)。
|
||||
- Redis Cluster 下 Lua 脚本涉及的多个 key 必须在同一个槽:key 用相同的哈希标签,如 `stock:{sku1}` 和 `stock:{sku1}:buyers`。
|
||||
|
||||
## 面试怎么讲
|
||||
|
||||
> “抢购的核心是不超卖和保护数据库。我在 Redis 用 Lua 脚本把‘限购检查、库存检查、扣减、记录用户’做成一个原子操作,预扣成功再发 MQ 异步建订单,数据库用唯一约束兜底防重复;下单失败或超时未支付时回补库存,定时对账。我写了并发测试:200 个请求抢 10 件,成功数固定是 10。”
|
||||
|
||||
追问准备:Redis 宕机怎么办(主从 + 对账,极端情况下暂停活动)?为什么不用分布式锁?消息丢了怎么办?
|
||||
Reference in new issue
Block a user