Go / 系统课时

管理在途请求清空

管理在途请求清空

在途请求清空不仅是“等 handler 返回”,还要把请求作用域和服务级后台任务分开管理。请求取消只应影响当前请求;进程停机则先停止接收新请求、等待现有请求完成,再结束后台任务,并用统一时间预算防止无限等待。

学习目标

  • 区分 r.Context() 的请求取消与进程停机信号
  • 使用服务级 context.Context 和 sync.WaitGroup 管理后台任务
  • 在请求清空、后台任务退出和总停机 deadline 之间建立明确顺序

分清两类取消信号

r.Context() 属于单个请求。客户端断开、HTTP/2 请求被取消,或处理器结束时,这个上下文会取消;依赖当前请求的数据库查询、RPC 和计算应监听它,避免客户端已经放弃后仍继续消耗资源。

进程停机信号属于整个服务。若一收到 SIGTERM 就把所有请求上下文一起取消,正在执行的请求会立即失败,实际上绕过了“清空在途请求”。更稳妥的顺序是:先让 Server.Shutdown 停止接收新流量并等待现有 handler 结束,再取消服务级后台任务。

请求取消与服务停机的作用域关系

这个分层还有一个直接好处:后台 worker 不会因为某个客户端断开而被误杀,而请求也不会因为服务级某个任务重启而失去自己的取消语义。

跟踪请求与后台任务

下面的程序用原子计数器观察活跃请求,用 http.Server.Shutdown 负责真正的 HTTP drain;服务级后台 worker 则由独立上下文和 sync.WaitGroup 管理。整个停机过程共享 6 秒预算,避免先无限等请求、再无限等后台任务。

go
package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"net/http"
	"os/signal"
	"sync"
	"sync/atomic"
	"syscall"
	"time"
)

func main() {
	log.SetFlags(0)

	var active atomic.Int64
	serviceCtx, cancelService := context.WithCancel(context.Background())
	var workers sync.WaitGroup

	workers.Add(1)
	go func() {
		defer workers.Done()
		<-serviceCtx.Done()
		log.Println("background worker stopped")
	}()

	mux := http.NewServeMux()
	mux.HandleFunc("/write", func(w http.ResponseWriter, r *http.Request) {
		active.Add(1)
		defer active.Add(-1)

		// 请求级取消只终止当前请求关联的工作。
		select {
		case <-time.After(2 * time.Second):
			fmt.Fprintln(w, "write committed")
		case <-r.Context().Done():
			log.Println("request canceled by client")
			return
		}
	})

	srv := &http.Server{
		Addr:              ":8080",
		Handler:           mux,
		ReadHeaderTimeout: 5 * time.Second,
	}

	sigCtx, stop := signal.NotifyContext(
		context.Background(),
		syscall.SIGINT,
		syscall.SIGTERM,
	)
	defer stop()

	serveErr := make(chan error, 1)
	go func() {
		log.Println("server listening on :8080")
		serveErr <- srv.ListenAndServe()
	}()

	select {
	case err := <-serveErr:
		if !errors.Is(err, http.ErrServerClosed) {
			log.Fatalf("serve failed: %v", err)
		}
		cancelService()
		workers.Wait()
		return
	case <-sigCtx.Done():
	}

	drainCtx, cancelDrain := context.WithTimeout(context.Background(), 6*time.Second)
	defer cancelDrain()

	log.Printf("drain started; active_requests=%d", active.Load())
	if err := srv.Shutdown(drainCtx); err != nil {
		log.Printf("http drain failed: %v", err)
		_ = srv.Close()
	} else {
		log.Println("http requests drained")
	}

	// HTTP handler 已经清空后,再停止服务级后台任务。
	cancelService()

	workersDone := make(chan struct{})
	go func() {
		workers.Wait()
		close(workersDone)
	}()

	select {
	case <-workersDone:
		log.Println("process exit")
	case <-drainCtx.Done():
		log.Println("background task drain timed out")
	}
}

预期结果:保存为 main.go,执行 go run main.go 后按 Ctrl+C。没有活跃请求时,典型输出为:

text
server listening on :8080
drain started; active_requests=0
http requests drained
background worker stopped
process exit

如果终止信号到来时 /write 已进入 handler,active_requests 可能是 1 或更大;只要请求在 6 秒预算内完成,日志会在它们返回后出现 http requests drained。实际请求数和时刻属于动态值。

避免清空过程留下漏洞

请求计数器适合观测,不应替代 Server.Shutdown 自己的连接管理。自己用 WaitGroup 包住每个 handler 并在停机时直接 Wait,如果没有先可靠阻止新请求进入,就可能出现“等待开始后还有新请求加入”的竞态设计,甚至让退出条件变得不可证明。

后台任务则必须显式定义所有权。服务启动时创建的 worker、刷新器、批处理循环应挂在服务级上下文上,并在退出路径中有对应的 cancel 和 Wait。若后台任务内部存在不可中断 I/O,仅有 WaitGroup 仍可能永久等待,因此它本身也应使用带超时的数据库、网络或队列调用。

建立可验收的退出顺序

可以把停机验收压缩成四个观察点:终止信号到来后新连接停止进入;已有请求要么完成,要么在总 deadline 到期后被兜底关闭;请求清空后服务级后台任务收到取消;最后所有受管 goroutine 在时间预算内结束。

这个顺序把“客户端取消”和“进程退出”拆成两个清晰作用域,也避免了两种常见失败:一收到系统信号就粗暴取消所有请求,以及 HTTP 已经停止但后台任务仍无限阻塞进程退出。

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

目录与阅读设置

阅读设置

17

记录一个想法

管理在途请求清空

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

登录哪都通