服务器在客户端超时时中断处理

在IT行业这个发展更新速度很快的行业，只有不停止的学习，才不会被行业所淘汰。如果你是Golang学习者，那么本文《服务器在客户端超时时中断处理》就很适合你！本篇内容主要包括##content_title##，希望对大家的知识积累有所帮助，助力实战开发！

我想知道是否有任何方法可以让 go http 服务器意识到客户端超时，并立即终止正在进行的请求的处理。目前，我已经尝试在客户端设置超时，这些超时实际上在客户端按预期工作，并且在达到超时后，请求以超出 context 截止日期（client.timeout waiting while waiting headers） 结束。

    req, err := http.newrequest(http.methodget, url, nil)
    if err != nil {
        log.fatal(err)
    }
    client := http.client{timeout: time.second}
    _, err = client.do(req)
    if err != nil {
        log.fatal(err)
    }

我还尝试了不同版本的客户端代码，例如使用带有上下文的请求，并得到了相同的结果，这对于客户端来说是可以的。

但是，当涉及到检测服务器端的超时时，结果表明，无论客户端的超时情况如何，也无论我希望发生什么，请求的处理都会继续，直到服务器完成其工作（我不知道是否有可能）是在客户端超时后立即终止并中止处理。

服务器端代码将是这样的（只是为了示例，在生产代码中它会更复杂）：

当运行前面的代码并且请求到达 http 服务器时，会发生以下事件序列：

1. 服务器在 sleep 之前打印
2. 服务器休眠
3. 客户端超时并终止，并显示错误 context 最后期限超出（等待标头时超出 client.timeout）
4. 服务器唤醒并在 sleep 后打印

但我希望在第 3 步终止该过程。

谢谢你这么说，我想知道你对此的想法，以及你认为我想做的事情是否可行。

解决方案

这里有一些不同的想法。首先，为了确认您的要求，您似乎想让客户端断开连接触发整个服务器关闭。为此，您可以执行以下操作：

1. 添加 context.withcancel 或 channel 用于传播关闭事件
2. 注意 http 处理程序中的断开连接并取消上下文
3. 添加一个 goroutine，在通道关闭时关闭服务器

这是一个完整的示例程序，它产生以下输出：

go run ./main.go
2021/03/04 17:56:44 client: starting request
2021/03/04 17:56:44 server: handler started
2021/03/04 17:56:45 client: deadline exceeded
2021/03/04 17:56:45 server: client request canceled
2021/03/04 17:56:45 server: performing server shutdown
2021/03/04 17:56:45 waiting for goroutines to finish
2021/03/04 17:56:45 all exited!

// main.go

package main

import (
    "context"
    "errors"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "sync"
    "time"
)

func main() {
    wg := &sync.WaitGroup{}
    srvContext, srvCancel := context.WithCancel(context.Background())
    defer srvCancel()

    srv := http.Server{
        Addr: ":8000",
        Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log.Printf("server: handler started")
            select {
            case <-time.After(2 * time.Second):
                log.Printf("server: completed long request")
                w.WriteHeader(http.StatusOK)
                w.Write([]byte("OK"))
            case <-r.Context().Done():
                log.Printf("server: client request canceled")
                srvCancel()
                return
            }
        }),
    }

    // add a goroutine that watches for the server context to be canceled
    // as a signal that it is time to stop the HTTP server.
    wg.Add(1)
    go func() {
        defer wg.Done()
        <-srvContext.Done()
        log.Printf("server: performing server shutdown")
        // optionally add a deadline context to avoid waiting too long
        if err := srv.Shutdown(context.TODO()); err != nil {
            log.Printf("server: shutdown failed with context")
        }
    }()

    // just simulate making the request after a brief delay
    wg.Add(1)
    go makeClientRequest(wg)

    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        fmt.Fprintf(os.Stderr, "Server failed listening with error: %v\n", err)
        return
    }

    log.Printf("waiting for goroutines to finish")
    wg.Wait()
    log.Printf("All exited!")
}

func makeClientRequest(wg *sync.WaitGroup) {
    defer wg.Done()
    // delay client request
    time.Sleep(500 * time.Millisecond)
    log.Printf("client: starting request")

    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://127.0.0.1:8000", http.NoBody)
    if err != nil {
        log.Fatalf("failed making client request")
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            log.Printf("client: deadline exceeded")
        } else {
            log.Printf("client: request error: %v", err)
        }
        return
    }

    // got a non-error response
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    log.Printf("client: got response %d %s", resp.StatusCode, string(body))
}

好了，本文到此结束，带大家了解了《服务器在客户端超时时中断处理》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！