Go / 系统课时
设计背压与优雅关闭
设计背压与优雅关闭
稳定的并发服务不仅要“能处理任务”,还要在队列已满时明确拒绝,在进程退出时停止接单、排空已接任务,并在超时后取消剩余工作。本课用一个有界 Worker Pool 串起背压、排空和超时关闭的完整控制路径。
学习目标
- 为队列满定义可观测、可预测的背压策略,而不是无限堆积任务。
- 实现“停止接单 → 关闭队列 → 等待排空”的优雅关闭顺序。
- 在关闭超时后取消未完成任务,并区分正常排空与强制终止。
背压从队列满时的决策开始
背压不是简单地“把任务放进 Channel”。当生产速度长期高于消费速度时,无界队列只是在延迟故障;真正的背压必须让上游感知容量已经耗尽,并采取等待、拒绝、降级或丢弃中的一种明确策略。
服务关闭则要改变入口状态:先停止接收新任务,再让已接收任务继续消费。若直接取消所有 Worker,队列中的任务会被静默遗弃;若只等待而没有截止时间,进程又可能永远无法退出。

用有界 Worker Pool 同时处理拒绝与关闭
下面的示例创建 2 个 Worker 和容量为 2 的等待队列。Submit 在队列无法立刻接收时返回 ErrFull;Shutdown 先在互斥锁保护下停止提交并关闭队列,然后等待 Worker 排空。若截止时间先到,则取消正在执行和尚未开始的任务。
package main
import (
"context"
"errors"
"fmt"
"sync"
"time"
)
var (
ErrClosed = errors.New("pool closed")
ErrFull = errors.New("queue full")
)
type Job struct {
ID int
}
type Pool struct {
jobs chan Job
wg sync.WaitGroup
mu sync.Mutex
closed bool
cancel context.CancelFunc
}
func NewPool(workers, queueSize int) *Pool {
ctx, cancel := context.WithCancel(context.Background())
p := &Pool{
jobs: make(chan Job, queueSize),
cancel: cancel,
}
for i := 0; i < workers; i++ {
p.wg.Add(1)
go func() {
defer p.wg.Done()
for job := range p.jobs {
fmt.Printf("start %d\n", job.ID)
// 超时关闭时,正在处理的任务也能收到取消信号。
select {
case <-time.After(250 * time.Millisecond):
fmt.Printf("done %d\n", job.ID)
case <-ctx.Done():
fmt.Printf("cancel %d\n", job.ID)
return
}
}
}()
}
return p
}
func (p *Pool) Submit(job Job) error {
p.mu.Lock()
defer p.mu.Unlock()
if p.closed {
return ErrClosed
}
// 非阻塞提交让队列满立即反馈给上游,形成背压。
select {
case p.jobs <- job:
return nil
default:
return ErrFull
}
}
func (p *Pool) Shutdown(ctx context.Context) error {
p.mu.Lock()
if !p.closed {
p.closed = true
// close 与 Submit 受同一把锁保护,避免向已关闭 Channel 发送。
close(p.jobs)
}
p.mu.Unlock()
done := make(chan struct{})
go func() {
p.wg.Wait()
close(done)
}()
select {
case <-done:
return nil
case <-ctx.Done():
// 超过关闭预算后,取消尚未完成的工作。
p.cancel()
<-done
return ctx.Err()
}
}
func main() {
p := NewPool(2, 2)
time.Sleep(20 * time.Millisecond)
for i := 1; i <= 5; i++ {
err := p.Submit(Job{ID: i})
switch err {
case nil:
fmt.Printf("accepted %d\n", i)
case ErrFull:
fmt.Printf("rejected %d: queue full\n", i)
default:
fmt.Printf("rejected %d: %v\n", i, err)
}
}
ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
defer cancel()
fmt.Println("shutdown:", p.Shutdown(ctx))
}运行示例:
go run main.go预期结果中,并发日志的具体行序可能不同,但容量和关闭状态应满足以下特征:
accepted 1
accepted 2
accepted 3
accepted 4
rejected 5: queue full
start <ID>
start <ID>
done <ID>
done <ID>
cancel <ID>
cancel <ID>
shutdown: context deadline exceeded<ID> 的实际值由并发调度顺序决定。这里最多只能同时执行 2 个任务,最多等待 2 个任务,因此第 5 个任务被拒绝;350 ms 的关闭预算不足以完成第二批任务,所以超时后会看到取消并返回 context deadline exceeded。
关闭顺序要由唯一 Owner 控制
生产代码中,关闭 Channel 的职责应属于拥有队列生命周期的组件,而不是任意 Worker 或调用方。示例中的 Shutdown 与 Submit 共用同一把锁,就是为了让“停止提交”和“关闭队列”成为一个原子边界,避免 send on closed channel。
正常关闭时应先从外部入口停止接单,例如让 HTTP Server 不再接受新请求,再调用业务 Worker Pool 的 Shutdown。只有当排空超过整体关闭预算时,才进入取消分支。对于不能安全中断的任务,还需要把任务状态写入持久化存储,以便重启后重试,而不是仅依赖内存队列。
背压策略和关闭策略必须成对设计:运行时用有限容量阻止积压无限增长,退出时用同一套容量边界明确哪些任务已接收、哪些被拒绝、哪些完成、哪些因超时取消。这样服务在流量尖峰和部署重启时都能保持可预测行为。