Go语言并发编程：实现高效事件监听与优雅关闭

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

func (s *Server) Serve() {
    s.routines.Add(1)
    defer s.routines.Done()
    defer s.listener.Close()

    for {
        select {
        case <-s.closeChan:
            // 收到关闭信号，退出循环
            return
        default:
            // 设置监听超时，避免一直阻塞
            s.listener.SetDeadline(time.Now().Add(2 * time.Second))
            conn, err := s.listener.Accept()
            if err != nil {
                // 处理超时或其他错误，继续循环或检查关闭信号
                if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
                    continue // 超时，继续检查关闭信号
                }
                // 其他错误处理
                return
            }
            // 处理连接
            go s.handleConn(conn) // 假设有处理连接的函数
        }
    }
}

func (s *Server) Close() {
    s.closeChan <- true // 发送关闭信号
    s.routines.Wait()   // 等待所有goroutine完成
}

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

// Server 结构体定义
type Server struct {
    listener  net.Listener
    closeChan chan struct{} // 使用空结构体作为信号，不占用内存
    routines  sync.WaitGroup
    running   bool // 标记服务器是否正在运行
    mu        sync.Mutex // 保护running状态
}

// NewServer 创建并初始化一个新的Server实例
func NewServer(addr string) (*Server, error) {
    listener, err := net.Listen("tcp", addr)
    if err != nil {
        return nil, fmt.Errorf("failed to listen: %w", err)
    }
    return &Server{
        listener:  listener,
        closeChan: make(chan struct{}),
        running:   false,
    }, nil
}

// Serve 启动服务器监听连接
func (s *Server) Serve() {
    s.mu.Lock()
    if s.running {
        s.mu.Unlock()
        return // 防止重复启动
    }
    s.running = true
    s.mu.Unlock()

    s.routines.Add(1)
    defer s.routines.Done() // 确保Serve goroutine退出时WaitGroup计数减一

    // 启动一个goroutine来处理关闭信号
    go func() {
        <-s.closeChan // 阻塞直到收到关闭信号
        s.listener.Close() // 调用Close方法，这将导致Serve中的Accept()立即返回错误
        fmt.Println("Server close signal received, listener closed.")
    }()

    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.Op == "accept" {
                if opErr.Err.Error() == "use of closed network connection" || opErr.Err == net.ErrClosed {
                    fmt.Println("Listener closed, exiting accept loop.")
                    return // 监听器已关闭，退出循环
                }
            }
            fmt.Printf("Error accepting connection: %v\n", err)
            // 其他非关闭错误，可能需要日志记录或重试策略
            continue
        }
        s.routines.Add(1) // 为每个连接处理goroutine增加计数
        go func() {
            defer s.routines.Done() // 确保连接处理goroutine退出时计数减一
            s.handleConn(conn)
        }()
    }
}

// handleConn 模拟处理单个连接
func (s *Server) handleConn(conn net.Conn) {
    defer conn.Close()
    fmt.Printf("Handling connection from %s\n", conn.RemoteAddr())
    // 模拟一些工作
    time.Sleep(1 * time.Second)
    _, err := conn.Write([]byte("Hello from server!\n"))
    if err != nil {
        fmt.Printf("Error writing to connection %s: %v\n", conn.RemoteAddr(), err)
    }
    fmt.Printf("Finished handling connection from %s\n", conn.RemoteAddr())
}

// Close 发送关闭信号并等待所有goroutine完成
func (s *Server) Close() {
    s.mu.Lock()
    if !s.running {
        s.mu.Unlock()
        return // 服务器未运行
    }
    s.running = false
    s.mu.Unlock()

    fmt.Println("Initiating server shutdown...")
    close(s.closeChan) // 关闭通道，通知监听goroutine
    s.routines.Wait()  // 等待所有goroutine（包括Serve和所有handleConn）完成
    fmt.Println("Server gracefully shut down.")
}

// 示例用法
func main() {
    serverAddr := "localhost:8080"
    server, err := NewServer(serverAddr)
    if err != nil {
        fmt.Fatalf("Failed to create server: %v", err)
    }

    go server.Serve() // 在一个单独的goroutine中启动服务器

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

    // 再次尝试启动，应被阻止
    fmt.Println("\nAttempting to restart server...")
    go server.Serve()
    time.Sleep(1 * time.Second) // 留时间观察
    fmt.Println("Restart attempt finished.")

    // 模拟客户端连接（在服务器关闭后尝试连接，会失败）
    fmt.Println("\nAttempting client connection after server shutdown...")
    conn, err := net.Dial("tcp", serverAddr)
    if err != nil {
        fmt.Printf("Client connection failed as expected: %v\n", err)
    } else {
        fmt.Println("Client connected unexpectedly after shutdown.")
        conn.Close()
    }
}