Go / 系统课时

设计背压与优雅关闭

设计背压与优雅关闭

稳定的并发服务不仅要“能处理任务”,还要在队列已满时明确拒绝,在进程退出时停止接单、排空已接任务,并在超时后取消剩余工作。本课用一个有界 Worker Pool 串起背压、排空和超时关闭的完整控制路径。

学习目标

  • 为队列满定义可观测、可预测的背压策略,而不是无限堆积任务。
  • 实现“停止接单 → 关闭队列 → 等待排空”的优雅关闭顺序。
  • 在关闭超时后取消未完成任务,并区分正常排空与强制终止。

背压从队列满时的决策开始

背压不是简单地“把任务放进 Channel”。当生产速度长期高于消费速度时,无界队列只是在延迟故障;真正的背压必须让上游感知容量已经耗尽,并采取等待、拒绝、降级或丢弃中的一种明确策略。

服务关闭则要改变入口状态:先停止接收新任务,再让已接收任务继续消费。若直接取消所有 Worker,队列中的任务会被静默遗弃;若只等待而没有截止时间,进程又可能永远无法退出。

有界队列背压与优雅关闭控制链路

用有界 Worker Pool 同时处理拒绝与关闭

下面的示例创建 2 个 Worker 和容量为 2 的等待队列。Submit 在队列无法立刻接收时返回 ErrFull;Shutdown 先在互斥锁保护下停止提交并关闭队列,然后等待 Worker 排空。若截止时间先到,则取消正在执行和尚未开始的任务。

go
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))
}

运行示例:

bash
go run main.go

预期结果中,并发日志的具体行序可能不同,但容量和关闭状态应满足以下特征:

text
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。只有当排空超过整体关闭预算时,才进入取消分支。对于不能安全中断的任务,还需要把任务状态写入持久化存储,以便重启后重试,而不是仅依赖内存队列。

背压策略和关闭策略必须成对设计:运行时用有限容量阻止积压无限增长,退出时用同一套容量边界明确哪些任务已接收、哪些被拒绝、哪些完成、哪些因超时取消。这样服务在流量尖峰和部署重启时都能保持可预测行为。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

设计背压与优雅关闭

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通