05.7 阶段 6 数据层、缓存与消息
本页目录
一、阶段定位
阶段 5(05.6)把服务暴露到网络上,本阶段解决"服务背后的数据怎么存、怎么读、怎么异步"。HTTP handler 后面通常接三层:关系库(MySQL/PostgreSQL)存业务数据、Redis 做热点缓存与分布式锁、Kafka 做异步解耦。这三层的工程做法有大量坑:连接池参数怎么配、事务里能不能调远程、缓存穿透怎么防、消息重复消费怎么办。
与前后阶段的衔接:
- 往上接阶段 4 的 pprof:数据库连接池打满、Redis 连接泄漏,要靠 pprof heap 与 goroutine profile 定位。
- 往上接阶段 3 的 context:所有 DB/Redis/Kafka 调用都必须接收
ctx,否则超时取消不生效。 - 往下接阶段 7(05.8):连接池指标、缓存命中率、消费延迟要做成 Prometheus 指标。
- 再往下接阶段 8(05.9):高并发下连接池与 goroutine 并发度的关系是核心调优点。
原提纲里的"卡点"展开成可判断的现象依据:
- 事务里混入网络调用:一个事务里调了 Redis 或下游 HTTP,事务持锁时间从毫秒变成秒,连接池被占满。
- 缓存空值与过期策略缺失:热点 key 过期瞬间,大量请求同时回源数据库(缓存击穿)。
- 消费失败后跳过消息:用
consumer.Commit()先提交再处理,处理失败时消息已丢,无法重投。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能配置 database/sql 连接池参数(MaxOpenConns/MaxIdleConns/ConnMaxLifetime) |
写出参数说明,并解释为什么 MaxOpenConns 要小于 DB 端 max_connections |
能用 pgx 或 sqlc 写查询,避免 N+1 |
对"查 100 个用户 + 各自订单"写出一条 JOIN 而非 100 次查询 |
| 能正确使用事务与隔离级别,事务里不做远程调用 | 代码评审时能指出"事务里调 Redis"是反模式 |
| 能实现缓存穿透/击穿/雪崩三类防护 | 用空值缓存 + 互斥重建 + 随机过期组合实现 |
| 能写一个带幂等键的 Kafka 消费者,重复投递不产生副作用 | 同一消息投递两次,数据库只有一条记录 |
| 能解释连接池上限与 goroutine 并发度的关系 | 说出"为什么 1000 并发请求不能配 1000 个 DB 连接" |
建议学时:
- 全职:2 周,约 60–70 小时。database/sql 与连接池 15 小时、事务与 N+1 15 小时、Redis 与缓存 15 小时、Kafka 与幂等 15 小时、实战 10 小时。
- 在职:5–6 周,约 70 小时。Redis 与 Kafka 各占一周。
学时分配建议:database/sql 与连接池 20%、事务与 SQL 优化 20%、Redis 与缓存 25%、分布式锁 10%、Kafka 与幂等 25%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| context 超时 | 能用 ctx 让下游函数退出 | 05.4 的 5.3 节 |
| 错误包装 | 能用 %w 保留错误链 |
05.3 的 5.3 节 |
| HTTP handler | 能写分层 handler + service | 05.6 的 5.3 节 |
| pprof | 能抓 heap 与 goroutine profile | 05.5 的 5.5 节 |
| SQL 基础 | 能写 SELECT/JOIN/WHERE/GROUP BY | 05.1 关系型通用能力 |
经验判断:有 Java 经验的人容易过度依赖 JPA/Hibernate 式 ORM,忽略 SQL 本身;有 Python 经验的人容易用裸 pymysql 不管理连接池。Go 生态里 sqlc 与 pgx 是主流,不要一上来就 GORM。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| database/sql | 连接池参数、Stmt、上下文超时、事务 | 能讲清原理 | 05.1 关系型通用能力 |
| 驱动与 ORM | pgx、GORM、Ent、sqlc 取舍 | 会用 | 05.2 MySQL |
| 事务与隔离 | 隔离级别、脏读/不可重复读/幻读、锁 | 能讲清原理 | 05.3 PostgreSQL |
| SQL 优化 | N+1、批量写入、预加载、索引配合 | 会用 | 05.1 关系型通用能力 |
| Redis 客户端 | go-redis、连接池、pipeline、Lua | 会用 | 09.3 缓存体系 |
| 缓存策略 | 穿透/击穿/雪崩、布隆、随机过期 | 能讲清原理 | 09.3 缓存体系 |
| 分布式锁 | Redis SET NX、过期、释放归属 | 会用 | 09.3 缓存体系 |
| Kafka | 生产、消费、消费者组、offset、幂等、顺序 | 会用 | 09.4 消息队列 |
进度管理建议:连接池与事务是面试高频,必须到"能讲清原理";缓存三问题与幂等要求"能讲清原理"。
五、分模块精讲
5.1 database/sql 与连接池参数
为什么需要它:Go 标准库 database/sql 提供连接池,但默认参数(MaxOpenConns=0 即无限)会让服务在并发上去后把数据库连接打满。连接池参数是生产环境必配的。
核心机制:
sql.Open只是创建连接池对象,不真正连接;第一次Ping或查询才建连。SetMaxOpenConns(n):最大打开连接数;0 表示无限。必须设,否则 DB 端max_connections(默认 151)会被打满。SetMaxIdleConns(n):最大空闲连接数;应 ≤ MaxOpenConns。SetConnMaxLifetime(d):连接最大存活时间;应小于 DB 端wait_timeout(MySQL 默认 8 小时),避免用被服务端断开的连接。SetConnMaxIdleTime(d):空闲连接最大存活时间。- 所有查询必须传
ctx,超时后数据库连接会被取消并归还。
最小可运行示例:
package main
import (
"context"
"database/sql"
"log"
"time"
_ "github.com/jackc/pgx/v5/stdlib" // PostgreSQL 驱动
)
func main() {
db, err := sql.Open("pgx", "postgres://user:pass@127.0.0.1:5432/app")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// 关键:连接池参数
db.SetMaxOpenConns(20) // 小于 DB 端 max_connections
db.SetMaxIdleConns(10) // 空闲 10
db.SetConnMaxLifetime(5 * time.Minute) // 小于 DB wait_timeout
db.SetConnMaxIdleTime(2 * time.Minute)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
var name string
err = db.QueryRowContext(ctx, "SELECT name FROM users WHERE id = $1", 1).Scan(&name)
if err != nil {
log.Fatal(err)
}
log.Println(name)
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
pq: sorry, too many clients already |
MaxOpenConns 无限,超过 DB max_connections | 设 SetMaxOpenConns(20) |
context deadline exceeded 后连接泄漏 |
没传 ctx,慢查询占着连接 | 所有查询用 QueryRowContext |
偶发 EOF / bad connection |
连接被 DB 端断开但池里还在用 | 设 SetConnMaxLifetime 小于 wait_timeout |
| 连接池里一直是旧连接 | SetMaxIdleConns 太大,空闲连接不回收 | 设 SetConnMaxIdleTime |
面试考法:"database/sql 连接池参数怎么设""为什么 MaxOpenConns 不能无限""为什么要传 ctx"。要点:MaxOpenConns 限制并发连接;Lifetime 小于 DB 超时;ctx 超时取消查询。
5.2 pgx、GORM、sqlc 取舍
为什么需要它:Go 生态有三种主流数据访问方式:裸 database/sql + pgx 驱动、全自动 ORM(GORM)、代码生成(sqlc)。选错了项目会很痛苦。
核心机制:
pgx:PostgreSQL 原生驱动,性能最好,支持原生类型;比database/sql快但绑定 PG。GORM:全自动 ORM,链式 API,开发快;但 SQL 不可控、N+1 容易犯、复杂查询难写。sqlc:从 SQL 生成类型安全的 Go 代码;写原生 SQL 但有类型检查;是 Go 社区推荐的"SQL 优先"方案。Ent:Facebook 开源的图模型 ORM,适合复杂关联查询。- 选择:小项目快速原型用 GORM;中大型项目用 sqlc + pgx;跨数据库用
database/sql接口。
最小可运行示例:
-- query.sql:sqlc 输入
-- name: GetUser :one
SELECT id, name, email FROM users WHERE id = $1;
-- name: ListUsers :many
SELECT id, name FROM users ORDER BY id LIMIT $1;
# sqlc 生成类型安全的 Go 代码
sqlc generate
# 产出 db.go、models.go、query.sql.go
# GetUser(ctx, 1) 返回 (*User, error),类型安全
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
GORM 查 N+1:循环里 db.First(&user) |
没预加载 | 用 Preload("Orders") 或 JOIN |
| sqlc 生成代码报错 | SQL 语法不对 | 在 PG 里先手动跑通 SQL |
| 用 GORM 写复杂查询性能差 | ORM 生成的 SQL 低效 | 改用 db.Raw 写原生 SQL |
面试考法:"GORM 与 sqlc 区别""为什么 Go 社区推荐 sqlc"。要点:GORM 自动但 SQL 不可控;sqlc 写 SQL 但类型安全;原生 SQL 性能可控。
5.3 事务与隔离级别
为什么需要它:事务保证多个操作要么全成功要么全回滚。但事务里做远程调用会持锁过久,是线上事故的高发原因。
核心机制:
- 隔离级别:读未提交、读已提交、可重复读、串行化。MySQL 默认 RR,PostgreSQL 默认 RC。
- 问题:脏读(读到未提交)、不可重复读(同事务两次读不同)、幻读(同条件两次范围查询行数不同)。
- 事务用法:
db.BeginTx(ctx, opts)→ 执行 SQL →Commit()或Rollback()。 - 铁律:事务里不做远程调用(HTTP、Redis、Kafka),因为网络延迟不可控,锁持有时长从毫秒变秒。
- 长事务排查:
pg_stat_activity看state = 'idle in transaction'。
最小可运行示例:
func transfer(ctx context.Context, db *sql.DB, from, to int, amount float64) error {
tx, err := db.BeginTx(ctx, nil) // 默认隔离级别
if err != nil {
return err
}
defer tx.Rollback() // Commit 后 Rollback 返回 ErrTxDone,无害
if _, err := tx.ExecContext(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, from); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, "UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, to); err != nil {
return err
}
// 注意:这里不要调 Redis 或 HTTP!
return tx.Commit()
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 数据库连接池被打满 | 事务里调远程,长事务占连接 | 把远程调用移到事务外 |
ERROR: current transaction is aborted, commands ignored until end of transaction block |
PG 里一条 SQL 失败后没 Rollback | 出错后立刻 Rollback,不要继续执行 |
| 并发扣减出现负余额 | RR 下没加行锁 | 用 SELECT ... FOR UPDATE 或乐观锁版本号 |
面试考法:"隔离级别有哪些""事务里为什么不能做远程调用""怎么防超卖"。要点:四级隔离;远程调用持锁;FOR UPDATE 或乐观锁。
5.4 N+1 与批量写入
为什么需要它:N+1 是 ORM 项目最常见性能问题——查 100 个用户再循环查订单,变成 101 次查询。批量写入则是另一个极端:一次插一行,10 万行变成 10 万次往返。
核心机制:
- N+1:先查 N 个主对象,再循环查每个的关联对象;应该改成一条 JOIN 或
IN查询。 - 批量写入:用
INSERT INTO t (a,b) VALUES (?,?),(?,?),(?,?)一次多行;或COPY(PG)/LOAD DATA(MySQL)。 - 批量大小:通常 100–1000 行一批,太大单条 SQL 超时,太小网络开销大。
- 预加载:GORM 的
Preload、sqlc 的手写 JOIN。
最小可运行示例:
// 反例:N+1
rows, _ := db.QueryContext(ctx, "SELECT id FROM users LIMIT 100")
for rows.Next() {
var id int
rows.Scan(&id)
db.QueryRowContext(ctx, "SELECT COUNT(*) FROM orders WHERE user_id = $1", id) // 100 次额外查询
}
// 正例:一条 JOIN
db.QueryRowContext(ctx, `
SELECT u.id, COUNT(o.id) AS order_count
FROM users u LEFT JOIN orders o ON o.user_id = u.id
GROUP BY u.id LIMIT 100
`)
// 批量插入
_, err := db.ExecContext(ctx, `
INSERT INTO users (name, age) VALUES
($1, $2), ($3, $4), ($5, $6)
`, "a", 20, "b", 30, "c", 40)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 查询慢,日志里有 100 条相似 SQL | N+1 | 改 JOIN 或 IN |
| 批量插入太慢 | 一次一行 | 改多值 INSERT,每批 500 行 |
| 批量插入大事务锁表 | 一批太大 | 控制每批 100–500 行 |
面试考法:"N+1 怎么发现""怎么批量插入""预加载的代价"。要点:日志里相似 SQL;多值 INSERT;JOIN 代价是返回大结果集。
5.5 Redis 客户端与缓存三问题
为什么需要它:Redis 是热点缓存默认方案,但缓存穿透、击穿、雪崩三类问题会让缓存形同虚设,甚至把数据库打挂。
核心机制:
- 客户端:
go-redis/v9,连接池参数PoolSize(默认 10 * CPU 核数)。 - 缓存穿透:查不存在的 key,每次都打到 DB。防护:缓存空值(短 TTL)或布隆过滤器。
- 缓存击穿:热点 key 过期瞬间,大量请求同时回源。防护:互斥重建(用
SET NX锁让一个请求回源,其他等待)或逻辑不过期。 - 缓存雪崩:大量 key 同时过期。防护:TTL 加随机抖动(如 5 分钟 ± 30 秒)。
- 一致性:先更新 DB 再删缓存(不是更新缓存);删除失败重试。
最小可运行示例:
package main
import (
"context"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
func getUser(ctx context.Context, rdb *redis.Client, db *sql.DB, id string) (*User, error) {
cacheKey := "user:" + id
// 1. 读缓存
if val, err := rdb.Get(ctx, cacheKey).Result(); err == nil {
return decodeUser(val)
}
// 2. 互斥重建:只让一个请求回源
lockKey := "lock:" + cacheKey
ok, err := rdb.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
if err != nil {
return nil, err
}
if !ok {
// 其他请求等 50ms 后重读缓存
time.Sleep(50 * time.Millisecond)
return getUser(ctx, rdb, db, id)
}
defer rdb.Del(ctx, lockKey)
// 3. 回源 DB
u, err := queryDB(ctx, db, id)
if err != nil {
// 穿透:缓存空值 60 秒
rdb.Set(ctx, cacheKey, "", 60*time.Second)
return nil, err
}
// 4. 写缓存,TTL 加随机抖动防雪崩
ttl := 5*time.Minute + time.Duration(time.Now().UnixNano()%60)*time.Second
rdb.Set(ctx, cacheKey, encodeUser(u), ttl)
return u, nil
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| DB QPS 突然飙高 | 缓存击穿:热点 key 过期 | 互斥重建或逻辑不过期 |
| 大量不存在 key 打到 DB | 缓存穿透 | 空值缓存或布隆过滤器 |
| 缓存重启后 DB 瞬间打挂 | 大量 key 同时过期(雪崩) | TTL 加随机抖动 |
| 缓存与 DB 不一致 | 更新 DB 后没删缓存 | 先更新 DB 再删缓存;失败重试 |
面试考法:"缓存穿透/击穿/雪崩区别""怎么防""缓存与 DB 一致性"。要点:穿透=不存在;击穿=热点过期;雪崩=大面积过期;先更新 DB 再删缓存。
5.6 分布式锁
为什么需要它:多实例部署时,定时任务、库存扣减需要互斥。单机 sync.Mutex 不够,要用 Redis 分布式锁。
核心机制:
SET key value NX EX seconds:只在 key 不存在时设置,带过期。- value 必须是唯一标识(如 UUID),释放时用 Lua 脚本验证 value 再删,防止误删别人的锁。
- 锁过期时间要覆盖业务最长执行时间;业务超长时用续期(如 Redisson 的 watchdog)。
- 强一致场景用 Redis RedLock(多节点),但生产多数用单节点 + 业务幂等。
最小可运行示例:
package main
import (
"context"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
var releaseLock = redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end
`)
func withLock(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration, fn func() error) error {
token := fmt.Sprintf("%d", time.Now().UnixNano())
ok, err := rdb.SetNX(ctx, key, token, ttl).Result()
if err != nil {
return err
}
if !ok {
return fmt.Errorf("lock busy: %s", key)
}
defer releaseLock.Run(ctx, rdb, []string{key}, token)
return fn()
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 业务执行慢,锁过期了别人拿到锁 | TTL 太短 | 设 TTL 大于业务最长耗时;或用续期 |
| 释放锁删了别人的锁 | 直接 DEL 不验证 value |
用 Lua 脚本验证 value |
| 锁没释放 | 进程崩溃,TTL 兜底 | 必须设过期时间 |
面试考法:"Redis 分布式锁怎么实现""为什么要用 Lua 释放""RedLock 是什么"。要点:SET NX EX + 唯一 token;Lua 验证后删;RedLock 多节点多数派。
5.7 Kafka 生产消费与幂等
为什么需要它:异步解耦用消息队列,但消息至少一次投递意味着重复消费是常态,消费者必须幂等。
核心机制:
- 生产:
Produce发送消息到 topic;key 决定分区(相同 key 进同分区,保证顺序)。 - 消费:消费者组(consumer group)下,分区在组内分摊;一个分区同一时间只能被组内一个消费者消费。
- offset:消费位点提交时机有三种——自动提交、手动提交(处理完再提交)、同步提交。
- 幂等:每条消息带唯一 ID(如业务主键 + 操作类型),消费者先查"是否处理过",处理过就跳过。
- 顺序:要全局顺序只能用单分区;分区内顺序由 key 保证。
最小可运行示例:
package main
import (
"context"
"database/sql"
"encoding/json"
"log"
"github.com/segmentio/kafka-go"
)
type OrderEvent struct {
OrderID string `json:"order_id"`
Action string `json:"action"`
}
func consume(ctx context.Context, r *kafka.Reader, db *sql.DB) error {
for {
m, err := r.ReadMessage(ctx)
if err != nil {
return err
}
var evt OrderEvent
if err := json.Unmarshal(m.Value, &evt); err != nil {
// 坏消息:提交 offset 跳过,不重试
_ = r.CommitMessages(ctx, m)
continue
}
// 幂等:用 order_id + action 作为唯一键
var exists bool
err = db.QueryRowContext(ctx,
"SELECT EXISTS(SELECT 1 FROM processed_events WHERE order_id = $1 AND action = $2)",
evt.OrderID, evt.Action).Scan(&exists)
if err != nil {
return err
}
if exists {
_ = r.CommitMessages(ctx, m) // 已处理,跳过
continue
}
// 业务处理
if err := handleOrder(ctx, db, evt); err != nil {
return err // 不提交,下次重投
}
// 记录处理位点
if _, err := db.ExecContext(ctx,
"INSERT INTO processed_events (order_id, action) VALUES ($1, $2)",
evt.OrderID, evt.Action); err != nil {
return err
}
_ = r.CommitMessages(ctx, m)
log.Printf("processed %s %s", evt.OrderID, evt.Action)
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 消息重复消费导致副作用 | 没做幂等 | 用唯一键 + processed_events 表 |
| 处理失败后消息丢失 | 先 Commit 再处理 | 处理成功后再 Commit |
| 顺序错乱 | 不同 key 的消息进不同分区 | 需要顺序用同 key;全局顺序单分区 |
| 消费者 rebalance 频繁 | 处理时间长超过 session.timeout | 调大 session.timeout;异步处理 |
面试考法:"Kafka 怎么保证不丢消息""怎么保证幂等""怎么保证顺序"。要点:手动提交;唯一键去重;同 key 同分区。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 配置连接池 | 用 pgx 连本地 PG,设 MaxOpenConns=20 | SHOW max_connections 与池参数对照 |
1 小时 |
| 事务转账 | 写一个 transfer 函数,两个账户扣款加款 |
故意让第二步失败,验证回滚 | 1 小时 |
| 缓存空值 | 查不存在的用户,缓存空值 60 秒 | 连续两次查询,第二次命中缓存 | 1 小时 |
| 分布式锁 | 用 SET NX EX 实现锁,Lua 释放 | 两个进程同时抢锁,只有一个拿到 | 1 小时 |
| Kafka 幂等消费 | 写一个消费者,用 processed_events 表去重 | 同一条消息发两次,DB 只一条记录 | 2 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 消除 N+1 | 给定循环查询代码,改成 JOIN | 日志里 SQL 从 101 条变 1 条 | 2 小时 |
| 批量写入 | 把循环 INSERT 改成多值 INSERT,每批 500 | 10 万行插入时间下降 10 倍 | 2 小时 |
| 互斥重建 | 给热点 key 加 SET NX 锁 | 并发 100 请求,DB 只收到 1 次回源 | 1 小时 |
| TTL 抖动 | 给所有缓存 key TTL 加 ±30 秒随机 | 同批 key 不在同一秒过期 | 0.5 小时 |
| 修复先提交后处理 | 给定先 Commit 后处理的代码,改成处理成功再 Commit | 故意让处理失败,消息重投 | 1 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 用户资料缓存层 | 实现 GetUser:读缓存→互斥回源→写缓存,穿透/击穿/雪崩都防护 | 压测下 DB QPS 平稳 | 6 小时 |
| 订单事件消费者 | 消费 Kafka 订单事件,幂等处理,失败重投 | 重复投递无副作用;失败重投 | 6 小时 |
| 库存扣减 | 用 Redis 预扣 + DB 最终扣,分布式锁防超卖 | 并发 1000 下不超卖 | 5 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
pq: sorry, too many clients already |
MaxOpenConns 无限 | pg_stat_activity 看连接数 |
设 SetMaxOpenConns(20) |
偶发 EOF / bad connection |
连接被 DB 端断开 | 看 DB wait_timeout;对比 ConnMaxLifetime | 设 Lifetime 小于 wait_timeout |
| DB QPS 突然飙高 | 缓存击穿/雪崩 | 看 Redis 命中率日志 | 互斥重建;TTL 抖动 |
| 缓存与 DB 不一致 | 更新 DB 后没删缓存 | 看业务代码顺序 | 先更新 DB 再删缓存;失败重试 |
| 消息重复消费产生副作用 | 没做幂等 | 看 processed_events 表 | 用唯一键去重 |
| 消息处理失败后丢失 | 先 Commit 后处理 | 看消费代码顺序 | 处理成功再 Commit |
| 连接池占满 | 事务里调远程,长事务 | pg_stat_activity 看 idle in transaction |
远程调用移到事务外 |
| 分布式锁误删 | 直接 DEL 不验证 token | 看释放代码 | 用 Lua 验证 token |
八、出口条件
全部勾选后再进入 05.8 阶段 7 可观测性与云原生部署。
- [ ] 能配置
database/sql连接池参数并解释每个参数 - [ ] 能用 pgx 或 sqlc 写查询,消除 N+1
- [ ] 能正确使用事务,事务里不做远程调用
- [ ] 能实现缓存穿透/击穿/雪崩三类防护
- [ ] 能用 Redis SET NX + Lua 释放实现分布式锁
- [ ] 能写带幂等键的 Kafka 消费者,重复投递无副作用
- [ ] 能解释连接池上限与 goroutine 并发度的关系
自测题:
SetMaxOpenConns为什么不能设为 0(无限)?- 要点:会超过 DB 端
max_connections(默认 151),导致too many clients;应设为小于 DB 上限。
- 要点:会超过 DB 端
- 事务里为什么不能调 HTTP 或 Redis?
- 要点:网络延迟不可控,持锁时间从毫秒变秒,连接池占满、锁冲突。
- 缓存穿透、击穿、雪崩的区别?
- 要点:穿透=查不存在的 key;击穿=热点 key 过期瞬间;雪崩=大量 key 同时过期。
- 分布式锁为什么要用 Lua 脚本释放?
- 要点:防止误删别人的锁——先 GET 验证 token 再 DEL,Lua 保证原子性。
- Kafka 消费者怎么保证幂等?
- 要点:每条消息带唯一键,先查 processed_events,处理过就跳过。
- 为什么要"先更新 DB 再删缓存"而不是"更新缓存"?
- 要点:更新缓存可能写入旧值;删除缓存让下次读时重建,避免并发覆盖。