Go TCP conn.Read()行为解析与连接关闭的最佳实践

func TCPHandler(conn net.Conn) {
    request := make([]byte, 4096)
    for {
        read_len, err := conn.Read(request)

        if err != nil {
            // 错误处理，可能包括io.EOF、网络超时等
            // ...
            break // 遇到错误时退出
        }

        if read_len == 0 {
            // 错误地认为只是暂时没有数据，继续循环
            // LOG("Nothing read")
            continue // 导致CPU高占用
        } else {
            // 处理接收到的数据
            // ...
        }
        // 注意：此处不应重复创建request切片
        // request := make([]byte, 4096)
    }
}

package main

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

// 模拟日志函数
func LOG(msg string) {
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"), msg)
}

// TCPHandler 负责处理单个TCP连接
func TCPHandler(conn net.Conn) {
    // 确保连接在函数退出时被关闭，释放资源
    defer func() {
        LOG(fmt.Sprintf("Closing connection from %s", conn.RemoteAddr()))
        if err := conn.Close(); err != nil {
            LOG(fmt.Sprintf("Error closing connection: %v", err))
        }
    }()

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

    LOG(fmt.Sprintf("Handling new connection from %s", conn.RemoteAddr()))

    for {
        // 设置读取超时，防止长时间阻塞
        // conn.SetReadDeadline(time.Now().Add(5 * time.Second))

        readLen, err := conn.Read(requestBuffer)

        if err != nil {
            // 处理io.EOF错误：对端已优雅关闭连接
            if err == io.EOF {
                LOG("Client closed connection gracefully.")
                break // 退出循环
            }

            // 处理网络错误，例如超时
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                LOG(fmt.Sprintf("Read timeout: %v", netErr))
                break // 退出循环
            }

            // 处理其他非io.EOF的错误，通常是致命的
            LOG(fmt.Sprintf("Error reading from connection: %v", err))
            break // 退出循环
        }

        // 理论上，如果err不是nil（特别是io.EOF），readLen可能为0。
        // 但如果err为nil且readLen为0，这仍然意味着对端关闭了连接。
        // 实际上，Go的net.Conn.Read在对端关闭时，通常会返回0和io.EOF。
        if readLen == 0 {
            LOG("Read 0 bytes with no error, peer likely closed connection.")
            break // 退出循环
        }

        // 成功读取到数据，进行业务处理
        receivedData := requestBuffer[:readLen]
        LOG(fmt.Sprintf("Received %d bytes: %s", readLen, string(receivedData)))
        // 示例：将接收到的数据原样写回
        if _, writeErr := conn.Write(receivedData); writeErr != nil {
            LOG(fmt.Sprintf("Error writing response: %v", writeErr))
            break
        }
    }
    LOG(fmt.Sprintf("Connection handler for %s exiting.", conn.RemoteAddr()))
}

// 模拟主函数，用于演示TCP服务器
func main() {
    listener, err := net.Listen("tcp", ":13798")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    defer listener.Close()
    LOG("Server listening on :13798")

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Error accepting connection: %v", err)
            continue // 继续尝试接受新的连接
        }
        go TCPHandler(conn) // 为每个新连接启动一个goroutine处理
        // runtime.Gosched() 在这里通常不是必需的，Accept本身是阻塞的
    }
}