Go语言中TCP套接字读写操作的同步与处理

package main

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

func handleErr(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

// writeFull 确保将所有字节写入连接
func writeFull(conn net.Conn, data []byte) error {
    totalWritten := 0
    for totalWritten < len(data) {
        n, err := conn.Write(data[totalWritten:])
        if err != nil {
            return err
        }
        totalWritten += n
    }
    return nil
}

func main() {
    host := "127.0.0.1:5678" // 假设连接本地服务器
    conn, err := net.Dial("tcp", host)
    handleErr(err)
    defer conn.Close()

    // 设置写入超时，防止长时间阻塞
    conn.SetWriteDeadline(time.Now().Add(5 * time.Second))

    message := "Test\n"
    err = writeFull(conn, []byte(message))
    handleErr(err)
    log.Printf("Sent: %s", message)

    // ... 后续读取操作
}

package main

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

// ... handleErr 和 writeFull 函数同上

// readUntilDelimiter 从连接中读取数据直到遇到指定分隔符
func readUntilDelimiter(conn net.Conn, delimiter byte) ([]byte, error) {
    var buffer bytes.Buffer
    buf := make([]byte, 1024) // 每次读取的临时缓冲区

    for {
        // 设置读取超时
        conn.SetReadDeadline(time.Now().Add(5 * time.Second))
        n, err := conn.Read(buf)
        if err != nil {
            if err == io.EOF { // 连接关闭
                break
            }
            return nil, err
        }
        buffer.Write(buf[:n])

        // 检查是否包含分隔符
        if bytes.ContainsRune(buffer.Bytes(), rune(delimiter)) {
            // 如果找到分隔符，提取并返回第一个完整消息
            // 实际应用中可能需要更复杂的逻辑来处理缓冲区中剩余的数据
            parts := bytes.SplitN(buffer.Bytes(), []byte{delimiter}, 2)
            return parts[0], nil
        }
    }
    return buffer.Bytes(), nil // 如果连接关闭，返回已读取的所有数据
}

func main() {
    host := "127.0.0.1:5678"
    conn, err := net.Dial("tcp", host)
    handleErr(err)
    defer conn.Close()

    // 发送消息
    message := "Test\n"
    err = writeFull(conn, []byte(message))
    handleErr(err)
    log.Printf("Sent: %s", message)

    // 读取响应
    reply, err := readUntilDelimiter(conn, '\n')
    handleErr(err)
    log.Printf("Received: %s", string(reply))
}

package main

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

func handleConnection(conn net.Conn) {
    defer conn.Close() // 确保连接在函数结束时关闭
    log.Printf("Handling new connection from %s", conn.RemoteAddr())

    // 设置读写超时
    conn.SetDeadline(time.Now().Add(30 * time.Second))

    buf := make([]byte, 1024)
    for {
        n, err := conn.Read(buf)
        if err != nil {
            if err != io.EOF {
                log.Printf("Read error for %s: %v", conn.RemoteAddr(), err)
            }
            break // 读取错误或连接关闭
        }

        receivedMsg := string(buf[:n])
        log.Printf("Received from %s: %s", conn.RemoteAddr(), receivedMsg)

        // 假设服务器收到消息后立即回复相同内容
        _, err = conn.Write([]byte("Echo: " + receivedMsg))
        if err != nil {
            log.Printf("Write error for %s: %v", conn.RemoteAddr(), err)
            break
        }
    }
    log.Printf("Connection from %s closed.", conn.RemoteAddr())
}

func main() {
    listener, err := net.Listen("tcp", "127.0.0.1:5678")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    defer listener.Close()
    log.Println("Server listening on 127.0.0.1:5678")

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