Go / 系统课时

复现超时与取消场景

复现超时与取消场景

本节用一个会故意阻塞的 HTTP 处理器,同时复现客户端整体超时和主动取消。你将直接观察客户端返回的错误与服务端 Request.Context() 的状态,并确认请求取消后处理器确实停止继续工作。

学习目标

  • 构造可重复的阻塞与延迟响应场景
  • 区分客户端超时、主动取消与服务端请求上下文取消
  • 用测试断言确认取消后不会留下持续执行的处理器

构造可控的阻塞请求

测试的关键不是“让请求偶尔变慢”,而是让处理器稳定等待一个足够长的时间,并同时监听 r.Context().Done()。这样客户端一旦超时或主动取消,服务端就能立即记录上下文状态,而不是继续睡满整个延迟周期。

下面是完整测试文件。它用 httptest.Server 启动真实 HTTP 服务,并通过缓冲通道把服务端观察到的 context 错误传回测试线程。

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

预期结果:

text
测试文件可由下方 go test 命令执行;client_timeout 与 explicit_cancel 两个子测试都应通过。

运行并观察取消传播

客户端的超时计时器和调用方的 cancel() 都发生在客户端进程内;它们不会把“deadline 数值”自动传成服务端的 deadline。HTTP 传输层中止请求后,服务端看到的是当前请求上下文被取消,因此 r.Context().Err() 通常是 context.Canceled。

客户端超时与主动取消的 HTTP 时序

在包含该测试文件的 Go 模块中执行:

bash
go test -run '^TestTimeoutAndCancel$' -v

预期输出:

text
=== 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 机器有调度抖动,仍能稳定判断超时配置是否真正阻止了遗留工作。

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

目录与阅读设置

阅读设置

17

记录一个想法

复现超时与取消场景

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

登录哪都通