一个导出接口在 handler 里直接开 goroutine 生成报表:go generateReport(id),请求立刻返回,用户就不用等了。上线后流量涨了几倍,进程内存持续上升,最后被系统杀掉。goroutine 本身很轻,但每个任务要读数据、拼 Excel、占内存;没有上限的并发等于把请求量直接放大成内存占用,数据库连接和 CPU 也被同时拉满。

第二周把任务改成内存队列,重启发布后用户来问:昨天提交的报表怎么没了。队列在进程内存里,进程一退出就全丢;多副本部署时,任务只进了其中一台实例,另外几台根本看不到。第三周加了定时清理,每天凌晨跑一次,结果三个实例各跑一遍,同一条数据被删了三次,日志里三份相同记录。

这篇讲 Go 服务里三类后台工作:请求触发的异步任务、需要持久化的队列任务、按时间触发的定时任务。重点不是「怎么开 goroutine」,而是并发上限、任务不丢、不重复执行、停机时怎么收尾。示例里的 asynq 和 Redis 本机没有服务,相关返回会标注「未在本机实测」;worker 池、cron、分布式锁的代码可以按文中的命令自己验证。

先分清三类后台工作

第一类是「请求内异步」:用户提交后马上返回,真正的处理在后台跑。它适合可丢失、可重试、耗时短的工作,比如记录审计日志、发一条非关键通知。第二类是「队列任务」:任务必须先落盘再执行,进程崩了还能被另一个 worker 捡起来,比如生成报表、发邮件、调用第三方。第三类是「定时任务」:按时间周期触发,和请求无关,比如每天对账、清理过期数据。

类型典型场景能不能丢推荐做法
请求内异步审计日志、非关键通知能丢,丢了不影响主流程有界 worker 池或 errgroup
队列任务报表、邮件、支付回调补偿不能丢,必须可重试asynq 或 River 这类持久队列
定时任务对账、清理、统计不能重复,错过要能补robfig/cron 加分布式锁或单实例调度

分类决定了实现方式。把「不能丢」的任务塞进 go func,等于接受它在重启时消失;把「能丢」的日志写进 Redis 队列,增加了运维成本却换不来业务价值。先问清楚失败后果,再选工具,比先写代码后补可靠性便宜。

任务从入队到确认
任务入队
worker 取出
执行业务
确认完成

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 可追踪得多。

当天能自己验证的练习

  1. 写一个有 3 个 worker、容量 5 的 channel 池,提交 20 个带编号的任务,打印每个任务的开始和结束,观察同时在跑的数量是否始终不超过 3。
  2. 把提交端改成带 default 分支的 select,队列满时返回错误,统计被拒绝的任务数,理解背压和拒绝的差别。
  3. 用 robfig/cron 每秒触发一次,任务里 sleep 3 秒,分别在不加和加上 SkipIfStillRunning 的情况下观察重叠次数。
  4. 起一个 Redis,用 SET NX PX 让两个客户端抢同一把锁,确认只有一个成功;等锁过期后再抢,观察第二个客户端的行为。
  5. 启动 asynq 的 worker 和入队端,提交同一个业务 id 的任务两次,查看队列里是否只有一个;再让任务执行到一半杀掉 worker,观察任务是否被重新投递。

小结

三句话:goroutine 没有上限,后台任务必须先有并发边界;会丢的任务用内存池,不能丢的用持久队列,并且按至少一次语义设计幂等;定时任务要防重入、防多实例重复,停机时先停入口再排空。

任务能可靠跑完,最后一个问题就是「怎么把它安全地放到线上」。下一篇从滚动发布时旧实例被 SIGTERM 直接杀掉、正在处理的请求全断开始,讲静态编译、配置校验、JSON 日志、健康检查的分工和优雅停机;后台任务决定异步工作是否可靠,部署方式决定整个服务在发布和故障时是否可用。