Go语言中net.Conn.Read()行为解析与TCP连接优雅关闭处理

func TCPHandler(conn net.Conn) {
    // 缓冲区应在循环外定义，除非每次都需要一个新的缓冲区
    request := make([]byte, 4096)
    for {
        read_len, err := conn.Read(request)

        if err != nil {
            // 处理连接关闭或超时等错误
            if err.Error() == "use of closed network connection" {
                fmt.Println("Conn closed, error might happened")
                break // 连接已关闭，退出循环
            }

            neterr, ok := err.(net.Error);
            if ok && neterr.Timeout() {
                fmt.Println("Client timeout!")
                break // 连接超时，退出循环
            }
            // 其他未知错误，也应退出
            fmt.Printf("Read error: %v\n", err)
            break
        }

        if read_len == 0 {
            // 错误：当read_len为0时，表示对端已关闭连接，不应继续
            fmt.Println("Nothing read") // 实际上是对端关闭信号
            continue // 这导致了高CPU使用率，因为会无限循环
        } else {
            // 处理读取到的数据
            fmt.Printf("Received %d bytes: %s\n", read_len, string(request[:read_len]))
        }
        // 注意：这里的 request := make([]byte, 4096) 是一个潜在的bug
        // 它会在每次循环中重新分配内存，覆盖之前的 request 变量
        // 如果需要新的缓冲区，应明确管理，通常不需要在每次读取后重新分配
    }
    // 确保在处理完成后关闭连接
    conn.Close()
    fmt.Println("Handler finished, connection closed.")
}

import (
    "fmt"
    "io" // 导入 io 包以检查 io.EOF
    "net"
    "log"
)

// 假设 LOG 是一个简单的日志函数
func LOG(msg string) {
    log.Println(msg)
}

func TCPHandler(conn net.Conn) {
    defer conn.Close() // 确保连接在函数退出时关闭
    request := make([]byte, 4096) // 缓冲区在循环外定义

    for {
        read_len, err := conn.Read(request)

        if err != nil {
            if err == io.EOF {
                // io.EOF 错误通常也表示对端已关闭连接
                LOG("Peer closed connection gracefully (io.EOF)")
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                LOG("Client timeout!")
            } else {
                LOG(fmt.Sprintf("Read error: %v", err))
            }
            break // 发生任何错误，都应退出循环
        }

        if read_len == 0 {
            // **关键修正点**：当read_len为0时，表示对端已关闭连接
            LOG("Peer closed connection (0 bytes read)")
            break // 退出循环，不再尝试读取
        } else {
            // 处理读取到的数据
            fmt.Printf("Received %d bytes: %s\n", read_len, string(request[:read_len]))
            // 在这里进行业务逻辑处理
        }
    }
    LOG("Connection handler finished.")
}

// 示例 main 函数（与原问题保持一致，但非本教程核心）
func main() {
    l, err := net.Listen("tcp", ":13798")
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    for {
        conn, err := l.Accept()
        if err != nil {
            log.Fatal(err)
        }
        go TCPHandler(conn)
        // runtime.Gosched() 在大多数情况下是不必要的，Go调度器会自动处理
    }
}