Go TCP连接中conn.Read()行为解析与高CPU占用问题规避

func TCPHandler(conn net.Conn) {
    request := make([]byte, 4096)
    for {
        read_len, err := conn.Read(request)
        // ... 错误处理逻辑 ...

        if read_len == 0 {
            // 误区：认为只是“Nothing read”，然后继续循环
            // LOG("Nothing read")
            continue // 导致忙等，CPU飙升
        } else {
            // 处理接收到的数据
        }
        // 原代码中此处有不必要的 make([]byte, 4096)
    }
}

package main

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

// TCPHandler 负责处理单个TCP连接的请求
func TCPHandler(conn net.Conn) {
    // 确保连接在函数退出时被关闭，释放资源
    defer func() {
        fmt.Printf("Closing connection from %s\n", conn.RemoteAddr())
        conn.Close()
    }()

    // 设置读取超时，防止客户端长时间不发送数据导致连接挂起
    // conn.SetReadDeadline(time.Now().Add(60 * time.Second)) // 可选：根据需要设置超时

    requestBuffer := make([]byte, 4096) // 在循环外一次性分配缓冲区

    for {
        // 重置读取超时，每次成功读取后刷新
        // if err := conn.SetReadDeadline(time.Now().Add(60 * time.Second)); err != nil {
        //  fmt.Printf("Error setting read deadline for %s: %v\n", conn.RemoteAddr(), err)
        //  break
        // }

        read_len, err := conn.Read(requestBuffer)

        if err != nil {
            if err == io.EOF {
                // 对端优雅关闭连接。Read返回0字节或部分字节后EOF。
                // 此时应退出循环，defer会处理连接关闭。
                fmt.Printf("Client %s closed connection gracefully (EOF).\n", conn.RemoteAddr())
                break
            }

            // 处理其他网络错误，如超时、连接重置等
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Printf("Client %s read timeout: %v\n", conn.RemoteAddr(), netErr)
                break
            }

            // 捕获“use of closed network connection”错误，这通常表示连接已被其他地方关闭
            // 但在 defer conn.Close() 的模式下，这种错误通常不会在 Read 期间发生，
            // 除非连接在 Read 之前已被强制关闭。
            if err.Error() == "use of closed network connection" {
                fmt.Printf("Connection from %s already closed during read attempt.\n", conn.RemoteAddr())
                break
            }

            // 记录其他未预期的错误并退出
            fmt.Printf("Error reading from %s: %v\n", conn.RemoteAddr(), err)
            break // 遇到任何其他错误也应退出循环
        }

        if read_len == 0 {
            // 明确：Read返回0字节表示对端已关闭连接。
            // 此时应退出循环，defer会处理连接关闭。
            fmt.Printf("Client %s sent 0 bytes, indicating closure.\n", conn.RemoteAddr())
            break
        }

        // 处理接收到的数据
        // 注意：requestBuffer[:read_len] 才是实际读取到的数据
        receivedData := requestBuffer[:read_len]
        fmt.Printf("Received %d bytes from %s: %s\n", read_len, conn.RemoteAddr(), string(receivedData))

        // 这里可以添加业务逻辑，例如解析请求、发送响应等
        // _, writeErr := conn.Write([]byte("Server received: " + string(receivedData)))
        // if writeErr != nil {
        //  fmt.Printf("Error writing to %s: %v\n", conn.RemoteAddr(), writeErr)
        //  break
        // }
    }
    fmt.Printf("Handler for %s finished.\n", conn.RemoteAddr())
}

// 示例主函数，用于启动TCP监听器
func main() {
    listener, err := net.Listen("tcp", ":13798")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    defer listener.Close()
    fmt.Println("Server listening on :13798")

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Failed to accept connection: %v", err)
            // 在实际应用中，这里可能需要更复杂的错误处理，例如在某些错误后退出循环
            continue
        }
        fmt.Printf("Accepted connection from %s\n", conn.RemoteAddr())
        go TCPHandler(conn) // 为每个新连接启动一个goroutine处理
        // runtime.Gosched() 通常在服务器循环中不是必需的，Go调度器会妥善处理
    }
}