取消一张网.Golang中通过上下文的侦听器

Question

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

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

我正在挣扎的一件事是取消一张网。正在等待Accept((的侦听器。我使用的是ListenConfig，我相信它在创建Listener时具有获取上下文的优势。但是，取消此上下文不会产生中止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.Listn((的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的源代码，你会发现它基本上调用了底层套接字accept，并且上下文没有通过管道传输。但是Accept很容易通过关闭侦听器来取消，所以完全管道化上下文并不是绝对必要的。