构建健壮的Go语言Socket Echo服务器：核心实践与常见陷阱解析

// server.go - 原始服务器代码 (存在问题)
package main

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

func echo_srv(c net.Conn, wg sync.WaitGroup) { // 问题2：WaitGroup按值传递
    defer c.Close()
    defer wg.Done()

    for {
        var msg []byte // 问题1：零长度缓冲区

        n, err := c.Read(msg) // 此处将导致问题
        if err != nil {
            fmt.Printf("ERROR: read\n")
            fmt.Print(err)
            return
        }
        fmt.Printf("SERVER: received %v bytes\n", n)

        n, err = c.Write(msg) // 写入零字节或未初始化数据
        if err != nil {
            fmt.Printf("ERROR: write\n")
            fmt.Print(err)
            return
        }
        fmt.Printf("SERVER: sent %v bytes\n", n)
    }
}

func main() {
    var wg sync.WaitGroup

    ln, err := net.Listen("unix", "./sock_srv")
    if err != nil {
        fmt.Print(err)
        return
    }
    defer ln.Close()

    conn, err := ln.Accept()
    if err != nil {
        fmt.Print(err)
        return
    }
    wg.Add(1)
    go echo_srv(conn, wg) // WaitGroup按值传递

    wg.Wait()
}

import (
    "fmt"
    "io" // 导入io包以使用io.EOF
    "net"
    "sync"
)

// echo_srv 修正后的连接处理函数
func echo_srv(c net.Conn, wg *sync.WaitGroup) { // 注意：wg现在是*sync.WaitGroup
    defer c.Close()
    defer wg.Done()

    fmt.Printf("SERVER: New 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: Connection from %s closed (EOF).\n", c.RemoteAddr())
            return
        } else if err != nil {
            // 其他读取错误
            fmt.Printf("SERVER ERROR: read from %s: %v\n", c.RemoteAddr(), err)
            return
        }

        fmt.Printf("SERVER: received %v bytes from %s\n", n, c.RemoteAddr())

        // 3. 将接收到的数据回写给客户端
        // 注意：只写入实际读取到的 n 个字节 (msg[:n])，而不是整个缓冲区
        _, err = c.Write(msg[:n]) // 忽略写入字节数，因为我们只是回显
        if err != nil {
            fmt.Printf("SERVER ERROR: write to %s: %v\n", c.RemoteAddr(), err)
            return
        }
        fmt.Printf("SERVER: sent %v bytes to %s\n", n, c.RemoteAddr())
    }
}

// main函数修正
func main() {
    var wg sync.WaitGroup // 声明一个 WaitGroup

    // 监听Unix域套接字
    // 注意：如果文件已存在，Listen可能会失败，需要手动删除或处理
    listener, err := net.Listen("unix", "./sock_srv")
    if err != nil {
        fmt.Printf("ERROR: Listen failed: %v\n", err)
        return
    }
    defer listener.Close() // 确保监听器关闭
    fmt.Printf("SERVER: Listening on Unix socket: %s\n", "./sock_srv")

    // 通常，服务器会在一个无限循环中接受多个连接
    // 但为了与原问题保持一致，这里只接受一个连接
    // 生产环境中应改为 for { conn, err := listener.Accept() ... }
    conn, err := listener.Accept()
    if err != nil {
        fmt.Printf("ERROR: Accept failed: %v\n", err)
        return
    }

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

    wg.Wait() // 等待所有处理连接的goroutine完成
    fmt.Println("SERVER: All connections handled. Shutting down.")
}

// server.go - 完整的Echo服务器实现
package main

import (
    "fmt"
    "io"
    "net"
    "os" // 用于处理Unix域套接字文件
    "sync"
)

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

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

    // 循环读取客户端发送的数据并回写
    for {
        // 分配一个缓冲区来接收数据
        buffer := make([]byte, 1024) // 缓冲区大小可根据需要调整

        // 从连接中读取数据
        n, err := c.Read(buffer)
        if err == io.EOF {
            // 客户端关闭连接，正常退出
            fmt.Printf("SERVER: Connection from %s closed (EOF).\n", c.RemoteAddr())
            return
        } else if err != nil {
            // 其他读取错误
            fmt.Printf("SERVER ERROR: read from %s: %v\n", c.RemoteAddr(), err)
            return
        }

        fmt.Printf("SERVER: received %v bytes from %