构建健壮的Go语言Socket Echo服务器：Read操作与缓冲区管理深度解析

var msg []byte // msg 是一个nil切片，长度和容量都为0
n, err := c.Read(msg)

// 分配一个1024字节的缓冲区
msg := make([]byte, 1024)
n, err := c.Read(msg)

if err == io.EOF {
    fmt.Printf("SERVER: Client %s disconnected (EOF).\n", c.RemoteAddr())
    return // 客户端已关闭连接，此goroutine可以退出
} else if err != nil {
    fmt.Printf("SERVER: Error reading from %s: %v\n", c.RemoteAddr(), err)
    return // 其他读取错误，也退出
}

// 只将实际读取的n个字节写回
_, err = c.Write(msg[:n])

package main

import (
    "fmt"
    "io"
    "net"
    "sync"
)

// echo_srv 处理单个客户端连接
func echo_srv(c net.Conn, wg *sync.WaitGroup) {
    defer c.Close()    // 确保连接在函数结束时关闭
    defer wg.Done()    // 确保WaitGroup计数器在goroutine结束时递减

    fmt.Printf("SERVER: Accepted connection from %s\n", c.RemoteAddr())

    // 循环读取和回写数据
    for {
        // 1. 分配一个缓冲区来接收数据
        msg := make([]byte, 1024) // 使用1KB缓冲区

        // 2. 从连接中读取数据
        n, err := c.Read(msg)
        if err == io.EOF {
            // 客户端已关闭连接
            fmt.Printf("SERVER: Client %s disconnected (EOF).\n", c.RemoteAddr())
            return // 退出goroutine
        } else if err != nil {
            // 其他读取错误
            fmt.Printf("SERVER: Error reading from %s: %v\n", c.RemoteAddr(), err)
            return // 退出goroutine
        }

        // 打印接收到的字节数和内容
        fmt.Printf("SERVER: Received %v bytes from %s: %s\n", n, c.RemoteAddr(), string(msg[:n]))

        // 3. 将接收到的数据（只回写实际读取的n个字节）写回客户端
        _, err = c.Write(msg[:n]) // 忽略写入的字节数，因为我们期望全部写入
        if err != nil {
            fmt.Printf("SERVER: Error writing to %s: %v\n", c.RemoteAddr(), err)
            return // 退出goroutine
        }
        fmt.Printf("SERVER: Sent %v bytes back to %s\n", n, c.RemoteAddr())
    }
}

func main() {
    var wg sync.WaitGroup

    // 监听Unix域套接字
    // 注意：实际应用中可能更常用TCP监听，例如 "tcp", ":8080"
    socketPath := "./sock_srv"
    ln, err := net.Listen("unix", socketPath)
    if err != nil {
        fmt.Printf("SERVER: Error listening on %s: %v\n", socketPath, err)
        return
    }
    defer ln.Close() // 确保监听器在main函数结束时关闭
    fmt.Printf("SERVER: Listening on %s...\n", socketPath)

    // 循环接受多个客户端连接
    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Printf("SERVER: Error accepting connection: %v\n", err)
            // 如果是临时错误，可以考虑继续循环；如果是致命错误，可能需要退出
            continue
        }

        wg.Add(1) // 每接受一个连接，WaitGroup计数器加1
        go echo_srv(conn, &wg) // 启动一个goroutine处理连接，并传递WaitGroup的指针
    }

    // 对于一个持续运行的服务器，通常不会在main函数末尾直接调用wg.Wait()，
    // 因为它会阻塞主goroutine，阻止接受新的连接。
    // 如果服务器需要优雅关闭并等待所有客户端goroutine完成，
    // 通常会在一个信号处理函数中调用 wg.Wait()。
    // 此处为演示，如果希望main函数在所有客户端处理完毕后退出，可以取消注释以下行：
    // wg.Wait()
    // fmt.Println("SERVER: All client goroutines finished.")
}

package main

import (
    "bufio"
    "fmt"
    "io"
    "net"
    "os"
    "strings"
)

func main() {
    stdin := bufio.NewReader(os.Stdin)

    // 连接到服务器
    socketPath := "./sock_srv"
    conn, err := net.Dial("unix", socketPath)
    if err != nil {
        fmt.Printf("CLIENT: Error connecting to %s: %v\n", socketPath, err)
        return
    }
    defer conn.Close()
    fmt.Printf("CLIENT: Connected to %s\n", socketPath)

    for {
        fmt.Print("Enter message to transmit (type 'quit' or 'exit' to close): ")
        msgInput, err := stdin.ReadString('\n')
        if err != nil {
            fmt.Printf("CLIENT: Error reading from stdin: %v\n", err)
            return
        }

        // 移除换行符
        msgInput = strings.TrimSpace(msgInput)

        if strings.ToLower(msgInput) == "quit" || strings.ToLower(msgInput) == "exit" {
            fmt.Println("CLIENT: Disconnecting...")
            return
        }

        // 发送消息