在 Golang 中通过 Context 取消 net.Listener

Question

我正在实现一个 TCP 服务器应用程序，它在无限循环中接受传入的 TCP 连接。

我试图在整个应用程序中使用 Context 来允许关闭，这通常很好用。

我正在努力解决的一件事是取消一个正在等待 Accept() 的 net.Listener。我正在使用 ListenConfig，我相信它的优点是在创建侦听器时采用 Context。但是，取消此上下文并不具有中止 Accept 调用的预期效果。

这是一个演示相同问题的小应用程序：

package main

import (
    "context"
    "fmt"
    "net"
    "time"
)

func main() {
    lc := net.ListenConfig{}

    ctx, cancel := context.WithCancel(context.Background())

    go func() {
        time.Sleep(2*time.Second)
        fmt.Println("cancelling context...")
        cancel()
    }()
    ln, err := lc.Listen(ctx, "tcp", ":9801")
    if err != nil {
        fmt.Println("error creating listener:", err)
    } else {
        fmt.Println("listen returned without error")
        defer ln.Close()
    }
    conn, err := ln.Accept()
    if err != nil {
        fmt.Println("accept returned error:", err)
    } else {
        fmt.Println("accept returned without error")
        defer conn.Close()
    }
}

我希望，如果没有客户端连接，当上下文在启动后 2 秒被取消时，Accept() 应该中止。但是，它只是坐在那里，直到您按 Ctrl-C 退出。

我的期望错了吗？如果是这样，传递给 ListenConfig.Listen() 的 Context 有什么意义？

有没有其他方法可以实现相同的目标？

Answer 1

我相信您应该在超时用完时关闭侦听器。然后，当Accept返回错误时，检查它是否是故意的（例如超时已过）。

这篇博文展示了如何在没有上下文的情况下安全关闭 TCP 服务器。代码中有趣的部分是：

type Server struct {
    listener net.Listener
    quit     chan interface{}
    wg       sync.WaitGroup
}

func NewServer(addr string) *Server {
    s := &Server{
        quit: make(chan interface{}),
    }
    l, err := net.Listen("tcp", addr)
    if err != nil {
        log.Fatal(err)
    }
    s.listener = l
    s.wg.Add(1)
    go s.serve()
    return s
}

func (s *Server) Stop() {
    close(s.quit)
    s.listener.Close()
    s.wg.Wait()
}

func (s *Server) serve() {
    defer s.wg.Done()

    for {
        conn, err := s.listener.Accept()
        if err != nil {
            select {
            case <-s.quit:
                return
            default:
                log.Println("accept error", err)
            }
        } else {
            s.wg.Add(1)
            go func() {
                s.handleConection(conn)
                s.wg.Done()
            }()
        }
    }
}

func (s *Server) handleConection(conn net.Conn) {
    defer conn.Close()
    buf := make([]byte, 2048)
    for {
        n, err := conn.Read(buf)
        if err != nil && err != io.EOF {
            log.Println("read error", err)
            return
        }
        if n == 0 {
            return
        }
        log.Printf("received from %v: %s", conn.RemoteAddr(), string(buf[:n]))
    }
}

在您的情况下，您应该Stop在上下文用完时调用。

如果您查看 的源代码TCPConn.Accept，您会看到它基本上调用了底层的 socket accept，并且上下文没有通过管道传输。但是Accept通过关闭侦听器很容易取消，因此完全不需要管道上下文。