如何停止读取UDP的Goroutine？通道关闭后未立即终止问题

这个问题我之前也碰到过！核心原因是你代码里的UDP读取调用（比如ReadFromUDP）是阻塞式的系统调用——当Goroutine卡在这个调用上时，select语句根本没机会去检查你的停止通道状态，直到有UDP数据进来触发读取返回，才会轮到select去处理停止通道的关闭信号。

先还原下你大概率会写的原始代码，问题就藏在这里：

func udpListener(conn *net.UDPConn, stop chan struct{}) {
    buf := make([]byte, 1024)
    for {
        select {
        case <-stop:
            fmt.Println("Goroutine exiting...")
            return
        default:
            // 这里会一直阻塞，直到有UDP数据进来
            n, addr, err := conn.ReadFromUDP(buf)
            if err != nil {
                fmt.Println("Read error:", err)
                return
            }
            // 处理数据包逻辑
            fmt.Printf("Received from %s: %s\n", addr, string(buf[:n]))
        }
    }
}

只要没UDP数据，Goroutine就卡在ReadFromUDP上，select完全没机会轮询到<-stop的分支，哪怕你已经关闭了停止通道。

下面给你两种靠谱的解决办法：

方案1：用Context+定期读取超时（保留UDP连接） #

如果之后还需要复用这个UDP连接，就用context.WithCancel配合SetReadDeadline，让Goroutine定期从阻塞的读取中醒过来，检查是否需要停止：

import (
    "context"
    "net"
    "time"
    "fmt"
)

func udpListener(conn *net.UDPConn, ctx context.Context) {
    buf := make([]byte, 1024)
    for {
        // 每次读取前设置一个短超时（比如100ms），到点就会从Read调用中返回
        err := conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
        if err != nil {
            fmt.Println("Failed to set read deadline:", err)
            return
        }

        select {
        case <-ctx.Done():
            fmt.Println("Goroutine terminated via context")
            return
        default:
            n, addr, err := conn.ReadFromUDP(buf)
            if err != nil {
                // 如果是超时错误，就继续循环检查Context
                if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                    continue
                }
                // 其他错误直接退出
                fmt.Println("Read error:", err)
                return
            }
            // 处理数据包
            fmt.Printf("Received from %s: %s\n", addr, string(buf[:n]))
        }
    }
}

调用时只需要创建Context并在需要停止时调用cancel()：

// 初始化UDP连接
conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("0.0.0.0"), Port: 8080})
if err != nil {
    panic(err)
}

// 创建可取消的Context
ctx, cancel := context.WithCancel(context.Background())
go udpListener(conn, ctx)

// 模拟业务逻辑，5秒后停止Goroutine
time.Sleep(5 * time.Second)
cancel()

方案2：直接关闭UDP连接（简单粗暴，无需保留连接） #

如果停止Goroutine后不需要再用这个UDP连接，直接关闭连接是最省事的——阻塞的ReadFromUDP会立刻返回错误，Goroutine就能直接退出：

func udpListener(conn *net.UDPConn, stop chan struct{}) {
    buf := make([]byte, 1024)
    for {
        select {
        case <-stop:
            fmt.Println("Closing UDP connection and exiting...")
            // 关闭连接会中断阻塞的Read调用
            _ = conn.Close()
            return
        default:
            n, addr, err := conn.ReadFromUDP(buf)
            if err != nil {
                fmt.Println("Read error:", err)
                return
            }
            // 处理数据包
            fmt.Printf("Received from %s: %s\n", addr, string(buf[:n]))
        }
    }
}

调用时，关闭停止通道或者发送信号后，Goroutine会立刻关闭连接，终止阻塞读取：

stop := make(chan struct{})
go udpListener(conn, stop)

// 需要停止时，关闭通道即可
close(stop)

总结 #

• 核心问题：阻塞的UDP读取调用抢占了Goroutine的执行权，导致select无法及时响应停止信号
• 保留连接选方案1，通过定期超时让Goroutine有机会检查停止信号
• 不需要连接选方案2，直接关闭连接中断阻塞读取，简单高效

内容的提问来源于stack exchange，提问作者Andrews