在 Golang 中通过上下文取消 net.Listener

本篇文章给大家分享《在 Golang 中通过上下文取消 net.Listener》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

我正在实现一个 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 秒取消 context 时，accept() 应该中止。然而，它只是一直待在那里，直到您按下 ctrl-c 组合键为止。

我的期望是错误的吗？如果是这样，传递给 listenconfig.listen() 的 context 有何意义？

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

解决方案

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

This blog post 展示了如何在没有上下文的情况下安全关闭 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 的源代码，您会发现它基本上调用底层套接字 accept，并且上下文不会通过那里进行管道传输。但是 accept 很容易通过关闭侦听器来取消，因此完全管道化上下文并不是绝对必要的。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~