Go 语言惯用实践：构建高效无阻塞的事件监听器与优雅关闭机制

package main

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

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在goroutine退出时关闭

    fmt.Println("Server started, listening for connections with timeout...")
    for {
        select {
        case <-s.closeChan:
            fmt.Println("Server received close signal via channel, shutting down...")
            return // 收到关闭信号，退出循环
        default:
            // 设置一个短期的截止时间，以允许select语句有机会检查closeChan
            // 但这引入了一个强制的最小延迟
            s.listener.SetDeadline(time.Now().Add(2 * time.Second))
            conn, err := s.listener.Accept()
            if err != nil {
                // 检查是否是超时错误，如果是，则继续循环以检查closeChan
                if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
                    // fmt.Println("Accept timed out, checking close channel...")
                    continue
                }
                // 如果是“use of closed network connection”错误，说明listener已被外部关闭
                if strings.Contains(err.Error(), "use of closed network connection") {
                    fmt.Println("Listener closed externally, exiting serve routine.")
                    return
                }
                fmt.Printf("Error accepting connection: %v\n", err)
                // 实际应用中可能需要更复杂的错误处理，例如记录日志并决定是否继续
                continue
            }

            // 正常处理连接
            s.routines.Add(1)
            go func(conn net.Conn) {
                defer s.routines.Done()
                defer conn.Close()
                fmt.Printf("Handling connection from %s\n", conn.RemoteAddr())
                time.Sleep(1 * time.Second) // 模拟连接处理
                fmt.Printf("Finished handling connection from %s\n", conn.RemoteAddr())
            }(conn)
        }
    }
}

func (s *Server) Close() {
    fmt.Println("Signaling server to close...")
    close(s.closeChan) // 关闭通道以发送广播信号
    s.routines.Wait()  // 等待所有活跃的goroutine完成
    fmt.Println("Server closed gracefully.")
}

package main

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

type IdiomaticServer struct {
    listener  net.Listener
    closeChan chan struct{}
    routines  sync.WaitGroup
}

func (s *IdiomaticServer) Serve() {
    s.routines.Add(1)
    defer s.routines.Done()
    // 注意：这里不再需要defer s.listener.Close()，因为listener将由专门的goroutine关闭

    // 启动一个独立的goroutine来监听关闭信号并关闭listener
    go func() {
        <-s.closeChan // 等待关闭信号
        fmt.Println("Close signal received, closing listener...")
        s.listener.Close() // 关闭listener会立即解除所有Accept()的阻塞
    }()

    fmt.Println("Idiomatic server listening for connections...")
    for {
        conn, err := s.listener.Accept()
        if err != nil {
            // 当listener被关闭时，Accept()会立即返回一个错误
            if strings.Contains(err.Error(), "use of closed network connection") {
                fmt.Println("Listener closed, exiting serve routine.")
                return // 收到关闭错误，退出主循环
            }
            fmt.Printf("Error accepting connection: %v\n", err)
            // 其他错误类型可能需要记录日志或进行重试
            continue
        }

        // 正常处理连接
        s.routines.Add(1)
        go func(conn net.Conn) {
            defer s.routines.Done()
            defer conn.Close()
            fmt.Printf("Handling connection from %s\n", conn.RemoteAddr())
            time.Sleep(1 * time.Second) // 模拟连接处理
            fmt.Printf("Finished handling connection from %s\n", conn.RemoteAddr())
        }(conn)
    }
}

func (s *IdiomaticServer) Close() {
    fmt.Println("Signaling idiomatic server to close...")
    close(s.closeChan) // 发送关闭信号
    s.routines.Wait()  // 等待所有活跃的goroutine完成
    fmt.Println("Idiomatic server closed gracefully.")
}

// 示例用法 (可用于测试，但通常不直接包含在教程主体中)
/*
func main() {
    // 测试有超时延迟的服务器
    fmt.Println("--- Testing Server with SetDeadline ---")
    listener1, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Fatalf("Failed to listen: %v", err)
    }
    server1 := &Server{
        listener:  listener1,
        closeChan: make(chan struct{}),
    }
    go server1.Serve()

    fmt.Println("Server with SetDeadline started on :8080. Waiting 5s then closing...")
    time.Sleep(5 * time.Second)
    server1.Close()
    fmt.Println("Server with SetDeadline finished.")
    fmt.Println("\n---------------------------------------\n")

    // 测试惯用服务器
    fmt.Println("--- Testing IdiomaticServer ---")
    listener2, err := net.Listen("tcp", ":8081")
    if err != nil {
        fmt.Fatalf("Failed to listen: %v", err)
    }
    server2 := &IdiomaticServer{
        listener:  listener2,
        closeChan: make(chan struct{}),
    }
    go server2.Serve()

    fmt.Println("IdiomaticServer started on :8081. Waiting 5s then closing...")
    time.Sleep(5 * time.Second)
    server2.Close()
    fmt.Println("IdiomaticServer finished.")
}
*/