Go语言中并发读写UDP连接的最佳实践

// 简化示例，仅展示核心问题
func new_conn_problematic(port int) (conn *net.UDPConn, inbound chan Packet, err error) {
    inbound = make(chan Packet, 100)
    conn, err = net.ListenUDP("udp4", &net.UDPAddr{Port: port})
    if err != nil { return }

    go func() {
        for {
            b := make([]byte, 1500)
            n, addr, err := conn.ReadFromUDP(b) // Goroutine A reads
            if err != nil { /* error handling */ continue }
            inbound <- Packet{addr, b[:n]}
        }
    }()
    return
}

// 假设在另一个地方调用 conn.WriteTo(data, remote_addr) // Goroutine B writes

import "net"

// 假设 addr 是从 conn.ReadFromUDP 返回的 *net.UDPAddr
func deepCopyUDPAddr(addr *net.UDPAddr) *net.UDPAddr {
    if addr == nil {
        return nil
    }
    newAddr := &net.UDPAddr{}
    *newAddr = *addr // 浅拷贝结构体字段 (Port, Zone)

    // 深拷贝 IP 切片
    if addr.IP != nil {
        newAddr.IP = make(net.IP, len(addr.IP))
        copy(newAddr.IP, addr.IP)
    }
    return newAddr
}

package main

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

const (
    UDP_PACKET_SIZE = 1500 // UDP最大数据报大小
    CHAN_BUF_SIZE   = 100  // 通道缓冲区大小
)

// Packet 结构体用于在goroutine之间传递UDP数据报
type Packet struct {
    Addr *net.UDPAddr // 远程地址，深拷贝以避免竞争
    Data []byte       // 数据内容
}

// deepCopyUDPAddr 对 net.UDPAddr 进行深拷贝
func deepCopyUDPAddr(addr *net.UDPAddr) *net.UDPAddr {
    if addr == nil {
        return nil
    }
    newAddr := &net.UDPAddr{}
    *newAddr = *addr // 浅拷贝结构体字段 (Port, Zone)

    // 深拷贝 IP 切片
    if addr.IP != nil {
        newAddr.IP = make(net.IP, len(addr.IP))
        copy(newAddr.IP, addr.IP)
    }
    return newAddr
}

// NewUDPConnection 建立一个UDP监听器，并启动独立的读写goroutine。
// 返回用于接收和发送数据报的通道。
func NewUDPConnection(port int) (inbound, outbound chan Packet, conn *net.UDPConn, err error) {
    inbound = make(chan Packet, CHAN_BUF_SIZE)
    outbound = make(chan Packet, CHAN_BUF_SIZE)

    conn, err = net.ListenUDP("udp4", &net.UDPAddr{Port: port})
    if err != nil {
        return nil, nil, nil, fmt.Errorf("failed to listen UDP on port %d: %w", port, err)
    }

    // 启动读取UDP数据报的goroutine
    go func() {
        for {
            b := make([]byte, UDP_PACKET_SIZE)
            n, addr, err := conn.ReadFromUDP(b)
            if err != nil {
                // 处理连接关闭错误，避免无限循环
                if netErr, ok := err.(net.Error); ok && netErr.Temporary() {
                    log.Printf("Temporary UDP read error: %v, retrying...", err)
                    time.Sleep(10 * time.Millisecond) // 短暂等待后重试
                    continue
                }
                if err.Error() == "use of closed network connection" {
                    log.Printf("UDP connection closed, reader goroutine exiting.")
                    return // 连接已关闭，退出读goroutine
                }
                log.Printf("Error: UDP read error: %v", err)
                continue
            }

            // 对返回的UDPAddr进行深拷贝，避免数据竞争
            copiedAddr := deepCopyUDPAddr(addr)

            // 尝试将数据发送到inbound通道，如果通道已满则记录警告
            select {
            case inbound <- Packet{Addr: copiedAddr, Data: b[:n]}:
                // 数据报已发送到inbound通道
            default:
                log.Printf("Warning: Inbound channel full, dropping packet from %s", copiedAddr.String())
            }
        }
    }()

    // 启动写入UDP数据报的goroutine
    go func() {
        for packet := range outbound { // 循环从outbound通道接收数据
            _, err := conn.WriteToUDP(packet.Data, packet.Addr)
            if err != nil {
                // 处理连接关闭错误
                if err.Error() == "use of closed network connection" {
                    log.Printf("UDP connection closed, writer goroutine exiting.")
                    return // 连接已关闭，退出写goroutine
                }
                log.Printf