Go语言中TCP套接字读写同步的最佳实践

package main

import (
    "fmt"
    "io"
    "log"
    "net"
    "time" // 引入time包用于设置超时
)

// handleErr 是一个错误处理辅助函数
func handleErr(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    // 连接TCP服务器
    host := "127.0.0.1:8080" // 假设本地有一个TCP服务器在8080端口
    conn, err := net.Dial("tcp", host)
    handleErr(err)
    defer conn.Close() // 确保连接关闭

    log.Printf("成功连接到服务器: %s", host)

    // 写入数据到套接字
    message := "Hello Server!\n"
    n, err := conn.Write([]byte(message))
    if err != nil {
        log.Printf("写入数据失败: %v", err)
        return
    }
    log.Printf("成功写入 %d 字节: %s", n, message)

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

    // 从套接字读取响应
    // 假设服务器会返回一行文本，我们可以使用一个循环来确保读取完整
    replyBuffer := make([]byte, 1024)
    var totalRead int
    for {
        readN, err := conn.Read(replyBuffer[totalRead:])
        if err != nil {
            if err == io.EOF {
                log.Println("服务器关闭连接")
                break
            }
            // 检查是否是读取超时
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                log.Println("读取响应超时")
                break
            }
            log.Printf("读取响应失败: %v", err)
            return
        }
        totalRead += readN
        // 简单判断是否读取到换行符作为消息结束标志
        if totalRead > 0 && replyBuffer[totalRead-1] == '\n' {
            break
        }
        // 如果缓冲区已满但未读到完整消息，可能需要更大的缓冲区或更复杂的协议解析
        if totalRead == len(replyBuffer) {
            log.Println("缓冲区已满，可能未读取完整消息")
            break
        }
    }

    if totalRead > 0 {
        log.Printf("收到响应: %s", string(replyBuffer[:totalRead]))
    } else {
        log.Println("未收到任何响应。")
    }
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
)

func handleConnection(conn net.Conn) {
    defer conn.Close()
    log.Printf("新连接来自: %s", conn.RemoteAddr().String())

    reader := bufio.NewReader(conn)
    for {
        message, err := reader.ReadString('\n')
        if err != nil {
            log.Printf("读取失败或连接关闭: %v", err)
            return
        }
        log.Printf("收到消息: %s", strings.TrimSpace(message))

        response := fmt.Sprintf("Echo: %s", message)
        _, err = conn.Write([]byte(response))
        if err != nil {
            log.Printf("写入失败: %v", err)
            return
        }
        log.Printf("发送响应: %s", strings.TrimSpace(response))
    }
}

func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("监听失败: %v", err)
    }
    defer listener.Close()
    log.Println("服务器正在监听 :8080")

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("接受连接失败: %v", err)
            continue
        }
        go handleConnection(conn) // 为每个连接启动一个goroutine
    }
}

func writeAll(conn net.Conn, data []byte) error {
    totalWritten := 0
    for totalWritten < len(data) {
        n, err := conn.Write(data[totalWritten:])
        if err != nil {
            return fmt.Errorf("写入数据失败: %w", err)
        }
        totalWritten += n
    }
    return nil
}