如何在Go语言中优雅地处理net.Read的等待与超时机制

func handler(conn net.Conn){
    // conn.SetReadTimeout(5e9) // 如果设置，超时会频繁发生
    for{
        data := make([]byte, 512)
        _, err := conn.Read(data)
        if err != nil {
            // 处理错误，例如io.EOF或超时
            // 如果是EOF，通常意味着连接已关闭，可能需要退出循环
            // 如果是超时，循环会继续，但可能频繁触发
            if err == io.EOF {
                fmt.Println("Client disconnected.")
                return
            }
            fmt.Printf("Read error: %v\n", err)
            // 考虑是否需要短暂休眠以避免CPU空转，但这并非最佳实践
            // time.Sleep(time.Millisecond * 100)
            continue
        }
        // 处理接收到的数据
        fmt.Printf("Received: %s\n", data)
    }
}

package main

import (
    "fmt"
    "io"
    "net"
    "time"
)

// 模拟一个TCP连接，实际应用中会由net.Listen生成
type MockConn struct {
    net.Conn
    readBuffer chan []byte
    closed     bool
}

func NewMockConn() *MockConn {
    return &MockConn{
        readBuffer: make(chan []byte, 10), // 缓冲区，模拟接收数据
    }
}

func (m *MockConn) Read(b []byte) (n int, err error) {
    if m.closed {
        return 0, io.EOF
    }
    select {
    case data := <-m.readBuffer:
        n = copy(b, data)
        return n, nil
    case <-time.After(500 * time.Millisecond): // 模拟底层Read的阻塞和超时
        return 0, fmt.Errorf("read timeout (mock)")
    }
}

func (m *MockConn) Write(b []byte) (n int, err error) {
    // 模拟写入
    fmt.Printf("MockConn Write: %s\n", b)
    return len(b), nil
}

func (m *MockConn) Close() error {
    m.closed = true
    close(m.readBuffer)
    fmt.Println("MockConn closed.")
    return nil
}

// 模拟发送数据到连接
func (m *MockConn) SimulateIncomingData(data []byte) {
    if !m.closed {
        select {
        case m.readBuffer <- data:
            fmt.Printf("Simulated incoming data: %s\n", data)
        case <-time.After(100 * time.Millisecond):
            fmt.Println("Failed to simulate incoming data: buffer full or slow receiver.")
        }
    }
}

// handler函数现在使用goroutine和channel来管理读取
func handler(conn net.Conn) {
    // 创建用于数据和错误通信的channel
    dataCh := make(chan []byte)
    errCh := make(chan error, 1) // 错误channel可以带缓冲，防止goroutine阻塞

    // 启动一个goroutine专门负责从网络连接读取数据
    go func() {
        defer close(dataCh) // 读取goroutine退出时关闭dataCh
        defer close(errCh)  // 读取goroutine退出时关闭errCh

        for {
            buffer := make([]byte, 512)
            n, err := conn.Read(buffer) // 这里的Read仍然是阻塞的
            if err != nil {
                // 如果发生错误，发送到错误channel并退出goroutine
                errCh <- err
                return
            }
            if n > 0 {
                // 如果读取到数据，发送到数据channel
                dataCh <- buffer[:n]
            }
            // 如果n=0且err=nil，说明没有数据但没有错误，继续循环
            // 注意：实际net.Read通常不会出现n=0且err=nil的情况，除非是特定的非阻塞IO模式。
            // 对于标准阻塞Read，n=0通常伴随EOF或超时。
        }
    }()

    // 使用select语句在主goroutine中监听数据、错误和自定义超时
    // 使用time.NewTicker更适合需要周期性超时的场景
    ticker := time.NewTicker(2 * time.Second) // 每2秒检查一次超时
    defer ticker.Stop() // 确保在函数退出时停止ticker

    fmt.Println("Handler started, waiting for data or timeout...")

    for {
        select {
        case data, ok := <-dataCh:
            if !ok {
                // dataCh已关闭，表示读取goroutine已退出，可能是由于连接关闭或错误
                fmt.Println("Data channel closed, exiting handler.")
                return
            }
            // 接收到数据，进行处理
            fmt.Printf("Received data: %s\n", string(data))
            // 每次收到数据后，重置超时计时器（如果需要）
            // ticker = time.NewTicker(2 * time.Second) // 如果是time.After，这里需要重新设置
        case err, ok := <-errCh:
            if !ok {
                // errCh已关闭，表示读取goroutine已退出
                fmt.Println("Error channel closed, exiting handler.")
                return
            }
            // 接收到错误，进行处理
            fmt.Printf("Error during read: %v\n", err)
            if err == io.EOF {
                fmt.Println("Client disconnected, exiting handler.")
            }
            // 根据错误类型决定是否退出循环
            return // 通常在遇到网络错误时退出处理循环
        case <-ticker.C: // 监听定时器channel
            // 发生自定义超时，可以在这里执行一些周期性任务，或者检测连接活跃性
            fmt.Println("Custom timeout: No data received for 2 seconds.")
            // 可以在这里发送心跳包，或者检查连接状态
        }
    }
}

func main() {
    mockConn := NewMockConn()
    defer mockConn.Close()

    // 在一个goroutine中运行handler，模拟服务器处理连接
    go handler(mockConn)

    // 模拟客户端发送数据
    time.Sleep(1 * time.Second)
    mockConn.SimulateIncomingData([]byte("Hello from client 1"))
    time.Sleep(1 * time.Second)
    mockConn.SimulateIncomingData([]byte("Hello from client 2"))

    // 模拟一段时间没有数据
    time.Sleep(3 * time.Second)

    // 再次发送数据
    mockConn.SimulateIncomingData([]byte("Hello again"))
    time.Sleep(1 * time.Second)

    // 模拟连接关闭
    fmt.Println("\nSimulating connection close...")
    mockConn.Close()

    // 给予goroutine一些时间来处理关闭事件
    time.Sleep(2 * time.Second)
    fmt.Println("Main finished.")
}