使用 Goroutine 和 Channel 实现优雅的 Go 事件监听

package main

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

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

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

    go func() {
        <-s.closeChan
        // 关闭服务器，释放资源等
        fmt.Println("Closing listener...")
        s.listener.Close()
        fmt.Println("Listener closed.")
    }()

    for {
        conn, err := s.listener.Accept()
        if err != nil {
            // 监听器可能被关闭，结束循环
            fmt.Println("Accept error:", err)
            return err
        }
        // 处理连接
        fmt.Println("Accepted connection from:", conn.RemoteAddr())
        go s.handleConn(conn)
    }
}

func (s *Server) handleConn(conn net.Conn) {
    defer conn.Close()
    // 处理连接逻辑
    // ...
}

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

func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("Error listening:", err)
        return
    }

    server := &Server{
        listener:  listener,
        closeChan: make(chan bool),
    }

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        if err := server.Serve(); err != nil {
            fmt.Println("Server error:", err)
        }
    }()

    // 模拟一段时间后关闭服务器
    //time.Sleep(5 * time.Second)
    server.Close()
    fmt.Println("Server closed.")

    wg.Wait()
    fmt.Println("All routines finished.")
}