Go / 系统课时
复现超时与取消场景
复现超时与取消场景
本节用一个会故意阻塞的 HTTP 处理器,同时复现客户端整体超时和主动取消。你将直接观察客户端返回的错误与服务端 Request.Context() 的状态,并确认请求取消后处理器确实停止继续工作。
学习目标
- 构造可重复的阻塞与延迟响应场景
- 区分客户端超时、主动取消与服务端请求上下文取消
- 用测试断言确认取消后不会留下持续执行的处理器
构造可控的阻塞请求
测试的关键不是“让请求偶尔变慢”,而是让处理器稳定等待一个足够长的时间,并同时监听 r.Context().Done()。这样客户端一旦超时或主动取消,服务端就能立即记录上下文状态,而不是继续睡满整个延迟周期。
下面是完整测试文件。它用 httptest.Server 启动真实 HTTP 服务,并通过缓冲通道把服务端观察到的 context 错误传回测试线程。
package timeoutcancel
import (
"context"
"errors"
"io"
"net"
"net/http"
"net/http/httptest"
"testing"
"time"
)
func newBlockingServer(observed chan<- error) *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
select {
case <-time.After(500 * time.Millisecond):
w.WriteHeader(http.StatusOK)
_, _ = io.WriteString(w, "late response")
observed <- nil
case <-r.Context().Done():
// 请求被客户端中止时,服务端应尽快结束当前处理。
observed <- r.Context().Err()
}
}))
}
func assertServerCanceled(t *testing.T, observed <-chan error) {
t.Helper()
select {
case err := <-observed:
if !errors.Is(err, context.Canceled) {
t.Fatalf("server context = %v, want context.Canceled", err)
}
t.Logf("server context: %v", err)
case <-time.After(time.Second):
t.Fatal("server handler did not stop after client cancellation")
}
}
func TestTimeoutAndCancel(t *testing.T) {
t.Run("client_timeout", func(t *testing.T) {
observed := make(chan error, 1)
server := newBlockingServer(observed)
defer server.Close()
client := &http.Client{Timeout: 80 * time.Millisecond}
resp, err := client.Get(server.URL)
if resp != nil {
_ = resp.Body.Close()
}
if err == nil {
t.Fatal("expected client timeout")
}
var netErr net.Error
if !errors.As(err, &netErr) || !netErr.Timeout() {
t.Fatalf("client error = %v, want timeout", err)
}
t.Logf("client timeout: %v", netErr.Timeout())
assertServerCanceled(t, observed)
})
t.Run("explicit_cancel", func(t *testing.T) {
observed := make(chan error, 1)
server := newBlockingServer(observed)
defer server.Close()
ctx, cancel := context.WithCancel(context.Background())
req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL, nil)
if err != nil {
t.Fatal(err)
}
done := make(chan error, 1)
go func() {
resp, err := http.DefaultClient.Do(req)
if resp != nil {
_ = resp.Body.Close()
}
done <- err
}()
// 等到处理器进入阻塞阶段后,再由调用方主动取消。
time.Sleep(80 * time.Millisecond)
cancel()
select {
case err := <-done:
if !errors.Is(err, context.Canceled) {
t.Fatalf("client error = %v, want context.Canceled", err)
}
t.Logf("client canceled: %v", errors.Is(err, context.Canceled))
case <-time.After(time.Second):
t.Fatal("client request did not return after cancellation")
}
assertServerCanceled(t, observed)
})
}预期结果:
测试文件可由下方 go test 命令执行;client_timeout 与 explicit_cancel 两个子测试都应通过。运行并观察取消传播
客户端的超时计时器和调用方的 cancel() 都发生在客户端进程内;它们不会把“deadline 数值”自动传成服务端的 deadline。HTTP 传输层中止请求后,服务端看到的是当前请求上下文被取消,因此 r.Context().Err() 通常是 context.Canceled。

在包含该测试文件的 Go 模块中执行:
go test -run '^TestTimeoutAndCancel$' -v预期输出:
=== RUN TestTimeoutAndCancel
=== RUN TestTimeoutAndCancel/client_timeout
<PATH>:<ID>: client timeout: true
<PATH>:<ID>: server context: context canceled
=== RUN TestTimeoutAndCancel/explicit_cancel
<PATH>:<ID>: client canceled: true
<PATH>:<ID>: server context: context canceled
--- PASS: TestTimeoutAndCancel (<TIME>)
--- PASS: TestTimeoutAndCancel/client_timeout (<TIME>)
--- PASS: TestTimeoutAndCancel/explicit_cancel (<TIME>)
PASS
ok <PACKAGE> <TIME><PATH>、<ID>、<PACKAGE> 和 <TIME> 会随文件位置、行号、包名与机器速度变化。真正需要核对的是两个客户端分支都返回错误,而且服务端两次都在超时保护窗口内观察到 context canceled。
判断请求是否真的停止
只看到客户端报错还不够。若处理器完全忽略 r.Context(),客户端虽然已经离开,服务端仍可能继续做数据库查询、远程调用或 CPU 计算。测试中的 observed 通道与 1 秒保护超时,就是用来证明处理器已经走到取消分支并结束。
生产代码应把请求上下文继续传给支持取消的下游 API,例如 QueryContext、Do 或其他接收 context.Context 的调用。对于纯 CPU 循环或不支持上下文的库,也要在合理粒度主动检查取消信号;客户端超时本身不会强制终止任意 Go 代码。
容易误判的边界
http.Client.Timeout 是客户端整次请求的上限,而服务端 Request.Context() 的生命周期由连接状态和服务端处理过程控制。不要断言服务端一定得到 context.DeadlineExceeded;跨网络时,客户端 deadline 通常表现为连接被中止,服务端因此收到 context.Canceled。
同时不要把极短的毫秒级阈值当作业务结论。测试应让“取消时间”和“正常完成时间”拉开明显差距,并用通道或断言验证处理器退出,这样即使 CI 机器有调度抖动,仍能稳定判断超时配置是否真正阻止了遗留工作。