Go TCP conn.Read()行为解析与正确处理连接关闭

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

        if err != nil {
            // 错误处理逻辑...
            break // 遇到错误通常应退出循环
        }

        if read_len == 0 {
            // 错误：将0字节读取视为“无数据，继续尝试”
            LOG("Nothing read")
            continue // 这会导致忙循环和高CPU占用
        } else {
            // 处理接收到的数据
            // do something
        }
        // 注意：原始代码中这里有一个 `request := make([]byte, 4096)`，
        // 这会不断创建新的切片，应避免在循环内部频繁创建。
    }
}

package main

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

// 模拟日志函数
func LOG(msg string) {
    fmt.Printf("[%s] %s\n", time.Now().Format("15:04:05"), msg)
}

func main() {
    l, err := net.Listen("tcp", ":13798")
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close() // 确保监听器关闭

    LOG("Listening on :13798")

    for {
        conn, err := l.Accept()
        if err != nil {
            log.Printf("Error accepting connection: %v", err)
            // 根据错误类型决定是否继续Accept
            if netErr, ok := err.(net.Error); ok && netErr.Temporary() {
                // 临时错误，可以稍作等待后重试
                time.Sleep(time.Millisecond * 5)
                continue
            }
            log.Fatal(err) // 非临时错误，可能需要退出
        }
        go TCPHandler(conn) // 为每个连接启动一个goroutine
        runtime.Gosched()   // 建议：如果Accept频率很高，可以考虑让出CPU
    }
}

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

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

    buffer := make([]byte, 4096) // 缓冲区应在循环外创建
    for {
        read_len, err := conn.Read(buffer)

        if err != nil {
            if err == io.EOF {
                // 对端已优雅关闭连接
                LOG("Client closed connection gracefully.")
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                // 网络超时错误
                LOG(fmt.Sprintf("Client timeout: %v", netErr))
            } else {
                // 其他网络错误
                LOG(fmt.Sprintf("Connection read error: %v", err))
            }
            break // 遇到任何错误都应退出循环，关闭连接
        }

        if read_len == 0 {
            // 理论上，当对端关闭连接时，Read()会返回io.EOF错误，
            // 但以防万一，如果返回0字节且无错误，也应视为连接关闭。
            // 这种情况在实际中较少见，io.EOF是更标准的信号。
            LOG("Read 0 bytes with no error, assuming peer closed.")
            break
        }

        // 处理接收到的数据
        receivedData := buffer[:read_len]
        LOG(fmt.Sprintf("Received %d bytes: %s", read_len, string(receivedData)))
        // 可以在这里进行业务逻辑处理，例如回写数据
        // _, writeErr := conn.Write([]byte("Echo: " + string(receivedData)))
        // if writeErr != nil {
        //     LOG(fmt.Sprintf("Write error: %v", writeErr))
        //     break
        // }
    }
}