一个导出接口在 handler 里直接开 goroutine 生成报表:go generateReport(id),请求立刻返回,用户就不用等了。上线后流量涨了几倍,进程内存持续上升,最后被系统杀掉。goroutine 本身很轻,但每个任务要读数据、拼 Excel、占内存;没有上限的并发等于把请求量直接放大成内存占用,数据库连接和 CPU 也被同时拉满。
第二周把任务改成内存队列,重启发布后用户来问:昨天提交的报表怎么没了。队列在进程内存里,进程一退出就全丢;多副本部署时,任务只进了其中一台实例,另外几台根本看不到。第三周加了定时清理,每天凌晨跑一次,结果三个实例各跑一遍,同一条数据被删了三次,日志里三份相同记录。
这篇讲 Go 服务里三类后台工作:请求触发的异步任务、需要持久化的队列任务、按时间触发的定时任务。重点不是「怎么开 goroutine」,而是并发上限、任务不丢、不重复执行、停机时怎么收尾。示例里的 asynq 和 Redis 本机没有服务,相关返回会标注「未在本机实测」;worker 池、cron、分布式锁的代码可以按文中的命令自己验证。
先分清三类后台工作
第一类是「请求内异步」:用户提交后马上返回,真正的处理在后台跑。它适合可丢失、可重试、耗时短的工作,比如记录审计日志、发一条非关键通知。第二类是「队列任务」:任务必须先落盘再执行,进程崩了还能被另一个 worker 捡起来,比如生成报表、发邮件、调用第三方。第三类是「定时任务」:按时间周期触发,和请求无关,比如每天对账、清理过期数据。
| 类型 | 典型场景 | 能不能丢 | 推荐做法 |
|---|---|---|---|
| 请求内异步 | 审计日志、非关键通知 | 能丢,丢了不影响主流程 | 有界 worker 池或 errgroup |
| 队列任务 | 报表、邮件、支付回调补偿 | 不能丢,必须可重试 | asynq 或 River 这类持久队列 |
| 定时任务 | 对账、清理、统计 | 不能重复,错过要能补 | robfig/cron 加分布式锁或单实例调度 |
分类决定了实现方式。把「不能丢」的任务塞进 go func,等于接受它在重启时消失;把「能丢」的日志写进 Redis 队列,增加了运维成本却换不来业务价值。先问清楚失败后果,再选工具,比先写代码后补可靠性便宜。
goroutine 不是队列
goroutine 是 Go 的并发执行单位,创建成本低,但有栈内存、调度和上下文切换的成本。更关键的是,它不是一种「限制」:go f() 写多少次就并发多少次,没有排队,没有上限,也没有重试。流量翻倍,goroutine 数量也翻倍;下游数据库、第三方接口不会因为你的进程还能创建 goroutine 就自动扩容。
无上限并发的危害是连锁的。内存先涨,因为每个任务都在读数据、拼对象;接着数据库连接池被占满,正常的同步请求开始排队;最后 CPU 在大量 goroutine 之间切换,吞吐反而下降。监控上看到的是「延迟升高、OOM、连接超时」,根因却是入口没有限流。
还有一种更隐蔽的写法:在 handler 里 go func(){ ... c.JSON(...) }(),把 *gin.Context 直接带进 goroutine。请求结束后上下文会被复用,goroutine 里再读写它,可能把响应写到已经关闭的连接上,或者读到下一个请求的数据。需要异步时用 c.Copy(),并且只复制需要的字段;更好的做法是异步任务根本不依赖 HTTP 上下文,只接收业务参数。
结论不是「不要用 goroutine」,而是「每次创建都要有边界」。边界可以是固定数量的 worker、带缓冲的 channel、errgroup.SetLimit,也可以是外部队列的并发配置。没有边界的并发迟早会撞到资源上限。
有界 worker 池:channel 加固定消费者
最小可用的模式是「一个有缓冲的 channel 加固定数量的 worker」。生产者往 channel 发任务,消费者从 channel 取,数量固定,天然限流。channel 满时生产者阻塞,这就是背压:上游变慢,而不是把任务无限堆进内存。
type Job struct {
ID string
}
type Pool struct {
jobs chan Job
wg sync.WaitGroup
}
func NewPool(workers, queueSize int) *Pool {
p := &Pool{jobs: make(chan Job, queueSize)}
for i := 0; i < workers; i++ {
p.wg.Add(1)
go func() {
defer p.wg.Done()
for job := range p.jobs {
process(job)
}
}()
}
return p
}
func (p *Pool) Submit(ctx context.Context, job Job) error {
select {
case p.jobs <- job:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (p *Pool) Close() {
close(p.jobs)
p.wg.Wait()
}
这段代码有四个要点。第一,worker 数量固定,任务再多也不会创建更多 goroutine。第二,channel 有容量,满了生产者等待,等待可以带上下文超时,避免请求无限挂起。第三,Close 先关闭 channel 再等待,worker 会把已入队的任务处理完,这是优雅停机的基础。第四,任务本身要能处理失败:记录日志、重试或落盘,不能 panic 把 worker 打死。
channel 满时也可以选择拒绝,而不是阻塞。对 HTTP 入口来说,阻塞会占住连接,拖慢所有请求;更合适的是用 select 的 default 分支立刻返回 503 或 429,让调用方稍后重试。选阻塞还是拒绝,取决于任务能不能等、上游有没有重试机制,以及队列长度代表的是「缓冲」还是「积压」。
内存池只适合可丢任务。进程退出时 channel 里的任务会消失,Close 只能保证已经开始处理的那批完成,不能保证未消费的任务落盘。需要不丢的任务,必须换成持久队列;不要给内存队列加个「优雅停机」就以为可靠了,机器断电一样会丢。
errgroup:一次并发扇出与取消
golang.org/x/sync/errgroup 适合「一个请求要并发调多个下游,全部成功才算成功」的场景。它把一组 goroutine 收成一个 Wait,任意一个返回错误就取消公共上下文,其他任务能提前退出;SetLimit 可以限制同时运行的数量,避免一次扇出过多。
g, ctx := errgroup.WithContext(c.Request.Context())
g.SetLimit(5)
for _, id := range ids {
id := id
g.Go(func() error {
return fetchAndSave(ctx, id)
})
}
if err := g.Wait(); err != nil {
c.JSON(http.StatusBadGateway, gin.H{"error": "upstream failed"})
return
}
SetLimit 是硬上限,达到上限后 Go 会阻塞,直到有空位。它适合批处理,但不适合长期驻留的任务队列:errgroup 的生命周期跟着一次请求,请求结束、上下文取消,里面的任务也会被取消。需要跨请求存活的任务,仍然要用 worker 池或持久队列。
注意闭包变量。Go 1.22 之后循环变量每轮独立,但在老版本或自定义循环里,直接把循环变量传给 goroutine 可能所有任务都拿到最后一个值。示例里显式写 id := id 是一个便宜的防御,读代码的人也能立刻看出这是有意复制。
取消不是万能的。下游如果忽略 ctx,取消信号传不过去,goroutine 仍会跑完;数据库驱动、HTTP 客户端要使用带 context 的方法,才能在中途退出。设计任务时把 ctx 一路传下去,比在出口处等超时更有效。
持久队列:asynq 与 River
持久队列把任务写进外部存储,worker 从存储里取,进程重启不影响任务本身。Redis 系的代表是 asynq,PostgreSQL 系的代表是 River。两者都提供重试、延迟、定时、并发控制,差别主要在存储依赖和运维形态。
asynq
基于 Redis,吞吐高,支持优先级队列、延迟任务、唯一任务和 Web 监控。代价是多一套 Redis 运维,Redis 的持久化配置决定任务能扛多大故障;内存不足时旧任务可能被淘汰。
River
基于 PostgreSQL,任务和业务数据在同一个事务里写入,天然一致;不需要额外存储。代价是吞吐受数据库影响,任务量大时会给主库增加压力,适合已经有 Postgres、任务量中等的系统。
选择时先看一致性需求。如果「下单成功」和「发通知任务入队」必须一起成功,River 可以在同一个数据库事务里完成,少了分布式事务的麻烦;asynq 则需要先提交订单再入队,并接受极小概率的入队失败,用补偿任务兜底。任务量很大、需要独立扩容时,Redis 系更合适。
无论选哪个,都要理解「至少一次」语义。worker 取到任务、执行业务、然后确认完成;如果进程在「执行完」和「确认」之间崩溃,任务会被重新投递,业务逻辑可能执行两次。队列保证的是「不丢」,不是「只执行一次」。所以发邮件、扣库存、写流水这些操作必须有幂等键或唯一约束。
asynq 的一条完整链路
下面的链路包括依赖、入队、worker、启动命令和接口返回。本机没有 Redis 服务,所以没有实际运行,返回内容是预期形状,明确标注未实测;你在本地起一个 Redis 后可以按同样步骤复现。
go mod init demo/jobsvc
go get github.com/hibiken/asynq@v0.25.1
go get github.com/redis/go-redis/v9@v9.7.0
入队端在 HTTP 处理函数里只做一件事:把任务写进队列,然后返回 202。不要在请求里同步执行重任务,也不要把业务数据塞进巨大的 payload;任务里传 id,worker 按 id 重新查数据,避免数据过期和队列体积膨胀。
client := asynq.NewClient(asynq.RedisClientOpt{Addr: "127.0.0.1:6379"})
defer client.Close()
payload, _ := json.Marshal(map[string]string{"report_id": id})
task := asynq.NewTask("report:generate", payload,
asynq.MaxRetry(5),
asynq.Timeout(10*time.Minute),
asynq.Unique(24*time.Hour),
)
info, err := client.Enqueue(task)
if err != nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "enqueue failed"})
return
}
c.JSON(http.StatusAccepted, gin.H{"task_id": info.ID, "queue": info.Queue})
worker 端注册处理器,按队列分配并发。下面这段是独立进程,不和 HTTP 服务混在一起;任务量大时可以单独扩容 worker,不影响 API 的实例数。
type ReportHandler struct{}
func (h *ReportHandler) ProcessTask(ctx context.Context, t *asynq.Task) error {
var p struct {
ReportID string `json:"report_id"`
}
if err := json.Unmarshal(t.Payload(), &p); err != nil {
return err
}
return generateReport(ctx, p.ReportID)
}
srv := asynq.NewServer(
asynq.RedisClientOpt{Addr: "127.0.0.1:6379"},
asynq.Config{Concurrency: 10, Queues: map[string]int{"critical": 6, "default": 4}},
)
mux := asynq.NewServeMux()
mux.Handle("report:generate", &ReportHandler{})
if err := srv.Run(mux); err != nil {
slog.Error("worker exited", "err", err)
}
预期返回是一个 202 和任务 id,形状如下,未在本机实测:
curl -i -X POST http://127.0.0.1:8080/v1/reports \
-H "Content-Type: application/json" \
-d '{"report_id":"r_1001"}'
# 未在本机实测(本机没有 Redis)
HTTP/1.1 202 Accepted
Content-Type: application/json; charset=utf-8
{"task_id":"...","queue":"default"}
启动命令分别是 go run ./cmd/api 和 go run ./cmd/worker,两者共享同一份 Redis 配置。真实部署时把配置从环境变量读入,worker 的并发数按任务类型和下游承受能力设置;一个 worker 池里同时跑重任务和轻任务,会让轻任务被重任务堵住,最好按队列隔离。
定时任务:防重入、防重复实例
robfig/cron/v3 是 Go 里常用的 cron 库,支持标准五段表达式和带秒的六段表达式。它只负责「到点触发」,不负责「只触发一次」和「上次没跑完怎么办」,这两件事要自己配。
c := cron.New(
cron.WithSeconds(),
cron.WithChain(
cron.SkipIfStillRunning(cron.DefaultLogger),
cron.Recover(cron.DefaultLogger),
),
)
c.AddFunc("0 0 3 * * *", func() { runDailyReport() })
c.Start()
SkipIfStillRunning 防止上一次还没结束、下一次又被触发,适合耗时可能超过周期的任务;Recover 接住任务里的 panic,避免一个 panic 把整个调度器带崩。没有这两个选项,任务一慢就会重叠,重叠的任务争抢同一批数据,问题比不执行更难查。
时区要显式设置。容器默认常用 UTC,代码里写「凌晨三点」可能实际是北京时间十一点。用 cron.WithLocation 指定业务时区,并确认镜像里有 tzdata。
多实例部署时,每个实例都启动 cron 就会重复执行。两种解法:只让一个专门的调度实例跑定时任务,其他实例不启动;或者每个实例都跑,但任务开头抢一把分布式锁,抢不到就直接返回。前者简单,后者更容错,适合实例数会弹性变化的环境。
分布式锁与幂等键
Redis 分布式锁的最小写法是 SET key value NX PX ttl:只有 key 不存在时才设置,并带过期时间,避免持有者崩溃后锁永远不释放。value 用随机串,释放时先比较 value 再删除,防止误删别人的锁。
ok, err := rdb.SetNX(ctx, "lock:daily-report", token, 10*time.Minute).Result()
if err != nil {
return err
}
if !ok {
return nil
}
defer func() {
const script = `
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end`
rdb.Eval(ctx, script, []string{"lock:daily-report"}, token)
}()
锁的过期时间要大于任务最长执行时间。任务可能跑得比预期久时,要么续期,要么把任务拆小;过期时间太短,锁会在任务中途消失,另一个实例进来重复执行,比不加锁更危险。释放用 Lua 比较并删除,不能直接 DEL,否则可能删掉别人刚拿到的锁。
锁只能减少重复,不能替代幂等。网络抖动、重试、worker 崩溃都可能导致同一业务被执行两次;真正兜底的是幂等键:给每次操作一个唯一标识,写库时加唯一约束,重复执行时捕获冲突并当成成功。发邮件可以用「业务 id 加模板」作为幂等键,扣库存用流水号,外部调用用请求 id。
asynq 的 Unique 选项能在入队层面去重,但它只保证一段时间内同一个任务只入队一次,不保证执行一次。任务执行完、确认之前崩溃,仍会重新投递。把唯一性和幂等分成两层看:入队去重减少重复,业务幂等保证重复无害。
优雅停机:先停入口,再排空任务
收到停止信号时,HTTP 服务和 worker 都要收尾。顺序是:先停止接受新请求和新任务,再等待正在处理的任务完成,最后关闭连接池和队列客户端。反过来的顺序会让正在跑的任务拿不到数据库连接,或者入队失败。
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
go func() {
if err := srv.Shutdown(ctx); err != nil {
slog.Error("http shutdown", "err", err)
}
}()
if err := pool.Close(); err != nil {
slog.Error("worker drain", "err", err)
}
<-ctx.Done()
等待要有上限。停机窗口通常由编排系统决定,超过时间会被强杀;排空逻辑必须设置一个比窗口略短的超时,超时后记录还有多少任务没完成,再退出。不要无限等待,否则发布卡住,最后仍然是硬杀,任务状态更不可控。
持久队列的 worker 停机时,正在执行的任务要么完成并确认,要么超时后被重新投递。后一种情况要求任务幂等,这也是前面反复强调的原因。停机不是「把进程杀掉」的技术细节,它直接影响任务会不会重复、会不会丢。
现象、原因与第一步
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 内存持续上涨后 OOM | 每个请求都开 goroutine,没有并发上限 | 看 goroutine 数量和任务队列长度,确认入口是否限流 |
| 重启后任务消失 | 任务只在内存 channel 或进程内 map 里 | 确认队列是否持久化,停机是否先排空 |
| 同一任务执行多次 | 至少一次语义加业务不幂等,或定时任务多实例重复 | 查任务执行日志的业务 id,检查唯一约束和分布式锁 |
| 队列越积越多 | 消费者并发不足,或下游变慢,没有背压和告警 | 看队列深度、任务耗时分布和 worker 并发配置 |
| 任务一直卡在执行中 | 没有超时,或任务在等一个不会返回的下游 | 看任务的超时设置和下游调用日志 |
| 定时任务在错误时间跑 | 容器时区是 UTC,表达式按本地时间写 | 打印调度器时区,核对 cron 表达式 |
| 停机时大量任务失败 | 进程被直接杀掉,没有排空窗口 | 检查停止信号处理和编排系统的宽限期 |
| Redis 故障后任务全停 | 队列依赖 Redis,且没有持久化和告警 | 确认 Redis 的持久化策略、内存上限和监控 |
| 同一报表被入队两次 | 接口重试或用户重复点击,没有唯一键 | 检查入队参数是否带业务唯一标识 |
边界与代价
队列不是无限缓冲。队列越长,任务延迟越大,失败重试也越多。要有队列深度和任务年龄的监控,超过阈值就告警或拒绝新任务。把队列当「永远不会满的垃圾桶」,下游一故障就会爆掉。
可见性超时是持久队列的核心参数。任务执行时间超过超时,队列会认为 worker 失联,把任务重新投递,于是出现并发执行。超时设得太短,长任务会被重复;设得太长,worker 崩溃后任务要等很久才被捡起。按任务的 p99 耗时设置,并让任务尽量短小,是更稳的做法。
Redis 的持久化不是绝对的。RDB 快照有丢失窗口,AOF 也有刷盘策略;机器故障、内存淘汰都可能丢任务。对「绝对不能丢」的任务,要么用 PostgreSQL 系队列,要么在业务侧有对账和补偿。队列是降低丢失概率的工具,不是数据库事务的替代品。
定时任务不是「配置一次就永远正确」。业务时区、夏令时、任务耗时变化、依赖的下游变更,都会让原本正确的表达式出问题。把调度配置写进代码、随版本发布,并在每次执行后记录结果和耗时,比在服务器上手工改 crontab 可追踪得多。
当天能自己验证的练习
- 写一个有 3 个 worker、容量 5 的 channel 池,提交 20 个带编号的任务,打印每个任务的开始和结束,观察同时在跑的数量是否始终不超过 3。
- 把提交端改成带
default分支的select,队列满时返回错误,统计被拒绝的任务数,理解背压和拒绝的差别。 - 用 robfig/cron 每秒触发一次,任务里
sleep3 秒,分别在不加和加上SkipIfStillRunning的情况下观察重叠次数。 - 起一个 Redis,用
SET NX PX让两个客户端抢同一把锁,确认只有一个成功;等锁过期后再抢,观察第二个客户端的行为。 - 启动 asynq 的 worker 和入队端,提交同一个业务 id 的任务两次,查看队列里是否只有一个;再让任务执行到一半杀掉 worker,观察任务是否被重新投递。
小结
三句话:goroutine 没有上限,后台任务必须先有并发边界;会丢的任务用内存池,不能丢的用持久队列,并且按至少一次语义设计幂等;定时任务要防重入、防多实例重复,停机时先停入口再排空。
任务能可靠跑完,最后一个问题就是「怎么把它安全地放到线上」。下一篇从滚动发布时旧实例被 SIGTERM 直接杀掉、正在处理的请求全断开始,讲静态编译、配置校验、JSON 日志、健康检查的分工和优雅停机;后台任务决定异步工作是否可靠,部署方式决定整个服务在发布和故障时是否可用。