Go语言Unix Socket通信：解决bufio写入不生效与并发连接处理问题

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "time"
)

func main() {
    // 服务端注册并监听Unix Socket
    socketPath := "serversock"
    os.Remove(socketPath) // 确保套接字文件不存在，避免冲突

    socket, err := net.ListenUnix("unix", &net.UnixAddr{Name: socketPath, Net: "unix"})
    if err != nil {
        panic(fmt.Errorf("监听Unix Socket失败: %w", err))
    }
    defer socket.Close() // 确保程序退出时关闭套接字
    defer os.Remove(socketPath) // 确保程序退出时删除套接字文件

    fmt.Println("服务端已启动，监听于", socketPath)

    // 服务端并发处理连接
    go func() {
        for {
            conn, err := socket.Accept()
            if err != nil {
                // 如果是套接字已关闭的错误，则退出循环
                if netErr, ok := err.(*net.OpError); ok && netErr.Op == "accept" && netErr.Err.Error() == "use of closed network connection" {
                    fmt.Println("服务端监听已关闭，退出Accept循环")
                    return
                }
                fmt.Printf("接受连接失败: %v\n", err)
                continue // 继续尝试接受下一个连接
            }
            fmt.Println("服务端：收到新连接")

            // 为每个新连接启动一个独立的goroutine进行读操作
            go handleConnection(conn)
        }
    }()

    // 客户端连接服务端并发送消息
    time.Sleep(100 * time.Millisecond) // 确保服务端有足够时间启动监听

    clientConn, err := net.DialUnix("unix", nil, &net.UnixAddr{Name: socketPath, Net: "unix"})
    if err != nil {
        panic(fmt.Errorf("连接服务端失败: %w", err))
    }
    defer clientConn.Close()

    writer := bufio.NewWriter(clientConn)
    message := "hello world\n"
    n, err := writer.WriteString(message)
    if err != nil {
        panic(fmt.Errorf("写入消息失败: %w", err))
    }
    fmt.Printf("客户端：已写入 %d 字节\n", n)

    // 客户端等待一段时间，观察服务端响应
    time.Sleep(1 * time.Second)
    fmt.Println("客户端：程序结束")
}

// handleConnection 处理单个客户端连接的读取操作
func handleConnection(conn net.Conn) {
    defer conn.Close() // 确保连接处理完毕后关闭

    reader := bufio.NewReader(conn)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            // 如果是EOF错误，表示客户端关闭连接
            if err.Error() == "EOF" {
                fmt.Println("服务端：客户端连接已关闭")
                return
            }
            fmt.Printf("服务端：读取消息失败: %v\n", err)
            return
        }
        fmt.Printf("服务端：收到消息 -> %q\n", line)
    }
}

服务端已启动，监听于 serversock
客户端：已写入 13 字节
服务端：收到新连接
客户端：程序结束

// ... (之前的代码保持不变)

    writer := bufio.NewWriter(clientConn)
    message := "hello world\n"
    n, err := writer.WriteString(message)
    if err != nil {
        panic(fmt.Errorf("写入消息失败: %w", err))
    }
    fmt.Printf("客户端：已写入 %d 字节\n", n)

    // 关键步骤：刷新缓冲区，确保数据发送
    err = writer.Flush()
    if err != nil {
        panic(fmt.Errorf("刷新缓冲区失败: %w", err))
    }
    fmt.Println("客户端：缓冲区已刷新，消息已发送")

// ... (之后的代码保持不变)

服务端已启动，监听于 serversock
客户端：已写入 13 字节
客户端：缓冲区已刷新，消息已发送
服务端：收到新连接
服务端：收到消息 -> "hello world\n"
客户端：程序结束
服务端：客户端连接已关闭

// 原始有问题的服务端Accept循环片段
go func() {
    for {
        conn, err := socket.Accept()
        if err != nil {
            // ... 错误处理
        }
        fmt.Println("Got connection")
        reader := bufio.NewReader(conn)
        line, err := reader.ReadString(byte('\n')) // 这里会阻塞
        if err != nil {
            // ... 错误处理
        }
        fmt.Println("Got line", line)
    }
}()

// ... (main函数中服务端监听部分)

    // 服务端并发处理连接
    go func() {
        for {
            conn, err := socket.Accept()
            if err != nil {
                // ... 错误处理
                continue
            }
            fmt.Println("服务端：收到新连接")

            // 为每个新连接启动一个独立的goroutine进行读操作
            go handleConnection(conn) // 将连接处理逻辑封装到单独的函数中
        }
    }()

// ... (handleConnection 函数定义)
func handleConnection(conn net.Conn) {
    defer conn.Close() // 确保连接处理完毕后关闭

    reader := bufio.NewReader(conn)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            // 如果是EOF错误，表示客户端关闭连接
            if err.Error() == "EOF" {
                fmt.Println("服务端：客户端连接已关闭")
                return
            }
            fmt.Printf("服务端：读取消息失败: %v\n", err)
            return
        }
        fmt.Printf("服务端：收到消息 -> %q\n", line)
    }
}