Golang中如何正确关闭net.Listener

在Go中正确关闭net.Listener需要仔细处理并发和连接管理。您的实现基本正确，但有几个改进点：

改进的连接管理

type Server struct {
    listener  net.Listener
    conns     map[int]net.Conn
    mtx       sync.RWMutex
    cancelled bool
    nextID    int
    wg        sync.WaitGroup
}

func NewServer() *Server {
    listener, err := net.Listen("tcp", ":9999")
    if err != nil {
        fmt.Println("Failed to create listener", err.Error())
        os.Exit(1)
    }

    srv := &Server{
        listener:  listener,
        conns:     make(map[int]net.Conn),
        mtx:       sync.RWMutex{},
        cancelled: false,
        nextID:    0,
        wg:        sync.WaitGroup{},
    }
    go srv.Serve()
    return srv
}

func (srv *Server) Serve() {
    for {
        conn, err := srv.listener.Accept()
        if err != nil {
            // 检查是否是监听器关闭导致的错误
            if srv.isCancelled() {
                return
            }
            fmt.Println("Failed to accept connection:", err.Error())
            continue
        }
        
        srv.mtx.Lock()
        id := srv.nextID
        srv.conns[id] = conn
        srv.nextID++
        srv.mtx.Unlock()
        
        srv.wg.Add(1)
        go srv.handleConnection(conn, id)
    }
}

func (srv *Server) handleConnection(conn net.Conn, id int) {
    defer srv.wg.Done()
    defer func() {
        conn.Close()
        srv.mtx.Lock()
        delete(srv.conns, id)
        srv.mtx.Unlock()
    }()

    fmt.Println("Accepted connection from", conn.RemoteAddr())
    
    buf := make([]byte, 1024)
    _, err := conn.Read(buf)
    if err != nil {
        if !srv.isCancelled() {
            fmt.Println("Read error", err.Error())
        }
        return
    }
}

func (srv *Server) isCancelled() bool {
    srv.mtx.RLock()
    defer srv.mtx.RUnlock()
    return srv.cancelled
}

func (srv *Server) Stop() {
    fmt.Println("Stop requested")
    
    srv.mtx.Lock()
    srv.cancelled = true
    srv.mtx.Unlock()

    // 关闭监听器，这会使得Accept()立即返回错误
    srv.listener.Close()
    
    // 关闭所有活跃连接
    srv.mtx.Lock()
    for id, conn := range srv.conns {
        conn.Close()
        delete(srv.conns, id)
    }
    srv.mtx.Unlock()
    
    // 等待所有处理协程完成
    srv.wg.Wait()
    fmt.Println("Stopped")
}

处理"use of closed network connection"错误

这个错误是预期的行为，可以通过检查错误类型来过滤：

func (srv *Server) Serve() {
    for {
        conn, err := srv.listener.Accept()
        if err != nil {
            if srv.isCancelled() {
                return
            }
            // 检查是否是监听器关闭导致的错误
            if opErr, ok := err.(*net.OpError); ok {
                if opErr.Err.Error() == "use of closed network connection" {
                    return
                }
            }
            // 或者使用errors包检查
            if errors.Is(err, net.ErrClosed) {
                return
            }
            fmt.Println("Failed to accept connection:", err.Error())
            continue
        }
        
        srv.mtx.Lock()
        id := srv.nextID
        srv.conns[id] = conn
        srv.nextID++
        srv.mtx.Unlock()
        
        srv.wg.Add(1)
        go srv.handleConnection(conn, id)
    }
}

使用context的替代方案

type Server struct {
    listener net.Listener
    conns    map[int]net.Conn
    mtx      sync.RWMutex
    nextID   int
    wg       sync.WaitGroup
    ctx      context.Context
    cancel   context.CancelFunc
}

func NewServer() *Server {
    listener, err := net.Listen("tcp", ":9999")
    if err != nil {
        fmt.Println("Failed to create listener", err.Error())
        os.Exit(1)
    }

    ctx, cancel := context.WithCancel(context.Background())
    
    srv := &Server{
        listener: listener,
        conns:    make(map[int]net.Conn),
        ctx:      ctx,
        cancel:   cancel,
    }
    go srv.Serve()
    return srv
}

func (srv *Server) Serve() {
    for {
        select {
        case <-srv.ctx.Done():
            return
        default:
        }
        
        conn, err := srv.listener.Accept()
        if err != nil {
            if errors.Is(err, net.ErrClosed) {
                return
            }
            fmt.Println("Failed to accept connection:", err.Error())
            continue
        }
        
        srv.mtx.Lock()
        id := srv.nextID
        srv.conns[id] = conn
        srv.nextID++
        srv.mtx.Unlock()
        
        srv.wg.Add(1)
        go srv.handleConnection(conn, id)
    }
}

func (srv *Server) Stop() {
    fmt.Println("Stop requested")
    srv.cancel()
    srv.listener.Close()
    
    srv.mtx.Lock()
    for id, conn := range srv.conns {
        conn.Close()
        delete(srv.conns, id)
    }
    srv.mtx.Unlock()
    
    srv.wg.Wait()
    fmt.Println("Stopped")
}

主要改进：

1. 使用sync.WaitGroup来等待所有连接处理完成
2. 使用map而不是slice来管理连接，避免nil值问题
3. 使用context进行更清晰的取消机制
4. 通过错误类型检查来过滤预期的关闭错误

这种方法提供了更清晰、更健壮的服务器关闭机制。