Go语言中实现优雅且高效的事件监听与服务关闭

type Server struct {
    listener  net.Listener
    closeChan chan struct{} // 使用空结构体更节省内存
    routines  sync.WaitGroup
}

func (s *Server) Serve() {
    s.routines.Add(1)
    defer s.routines.Done()
    defer s.listener.Close() // 确保listener在协程退出时关闭

    for {
        select {
        case <-s.closeChan:
            // 收到关闭信号，准备退出
            fmt.Println("Server received close signal, shutting down...")
            return // 退出Serve协程
        default:
            // 设置Accept的超时，以避免长时间阻塞
            s.listener.SetDeadline(time.Now().Add(2 * time.Second))
            conn, err := s.listener.Accept()
            if err != nil {
                // 检查是否是超时错误，如果是则继续循环
                if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                    continue
                }
                // 其他错误（如listener已关闭），则退出
                fmt.Printf("Error accepting connection: %v\n", err)
                return
            }
            // 处理连接的逻辑，通常在一个新的goroutine中
            s.routines.Add(1)
            go func(conn net.Conn) {
                defer s.routines.Done()
                defer conn.Close()
                // handle conn logic
                fmt.Printf("Handling connection from %s\n", conn.RemoteAddr())
                time.Sleep(1 * time.Second) // 模拟处理
            }(conn)
        }
    }
}

func (s *Server) Close() {
    close(s.closeChan) // 发送关闭信号
    s.routines.Wait()  // 等待所有协程完成
    fmt.Println("All server routines finished.")
}

import (
    "fmt"
    "net"
    "sync"
    "time"
)

type ImprovedServer struct {
    listener  net.Listener
    closeOnce sync.Once // 确保Close操作只执行一次
    routines  sync.WaitGroup
    // closeChan用于在外部触发关闭，但Serve内部不再直接监听它
    // 相反，它用于通知一个专门的goroutine来关闭listener
    closeChan chan struct{} 
}

// NewImprovedServer 创建一个新的服务器实例
func NewImprovedServer(addr string) (*ImprovedServer, error) {
    lis, err := net.Listen("tcp", addr)
    if err != nil {
        return nil, fmt.Errorf("failed to listen: %w", err)
    }
    return &ImprovedServer{
        listener:  lis,
        closeChan: make(chan struct{}),
    }, nil
}

func (s *ImprovedServer) Serve() {
    s.routines.Add(1)
    defer s.routines.Done()

    // 启动一个独立的goroutine来监听关闭信号并关闭listener
    go func() {
        <-s.closeChan // 阻塞直到接收到关闭信号
        fmt.Println("Closing listener...")
        s.listener.Close() // 关闭listener，这将使Accept()立即返回错误
    }()

    fmt.Printf("Server listening on %s\n", s.listener.Addr())
    for {
        conn, err := s.listener.Accept()
        if err != nil {
            // 检查错误是否是由于listener关闭引起的
            if opErr, ok := err.(*net.OpError); ok && opErr.Err.Error() == "use of closed network connection" {
                fmt.Println("Listener closed, exiting Serve routine.")
                return // Listener已关闭，退出Serve协程
            }
            // 针对其他非关闭引起的错误，进行日志记录或处理
            fmt.Printf("Error accepting connection: %v\n", err)
            // 根据实际情况，可能需要决定是继续循环还是退出
            // 这里我们假设其他错误也应导致退出，或者在重试策略后退出
            return 
        }

        // 处理连接的逻辑，通常在一个新的goroutine中
        s.routines.Add(1)
        go func(conn net.Conn) {
            defer s.routines.Done()
            defer conn.Close()
            // handle conn logic
            fmt.Printf("Handling connection from %s\n", conn.RemoteAddr())
            time.Sleep(1 * time.Second) // 模拟处理
        }(conn)
    }
}

func (s *ImprovedServer) Close() {
    s.closeOnce.Do(func() {
        fmt.Println("Initiating server shutdown...")
        close(s.closeChan) // 发送关闭信号给专门的goroutine
        s.routines.Wait()  // 等待所有协程完成，包括Serve和所有连接处理协程
        fmt.Println("Improved server gracefully shut down.")
    })
}

func main() {
    server, err := NewImprovedServer(":8080")
    if err != nil {
        fmt.Fatalf("Failed to create server: %v", err)
    }

    go server.Serve()

    // 模拟服务器运行一段时间后关闭
    time.Sleep(5 * time.Second) 
    server.Close()

    // 确保main协程不会立即退出，以便观察输出
    time.Sleep(1 * time.Second) 
}