Go 的 select 实战:超时、非阻塞收发与优雅退出的三个套路

很多人学 Go 并发,select 只会写「从多个 channel 里随便读一个」。但实战里 select 真正好用的是三个套路:给操作加超时、非阻塞地试探 channel、以及优雅关闭 goroutine。这三个不掌握,写出来的并发代码要么卡死,要么泄漏 goroutine。这篇一个一个过。

套路一:给 channel 操作加超时

朴素写法:直接从 channel 读,读不到就永远阻塞。

go 复制代码

// 危险:worker 出问题没往 ch 写,这里会永久卡住
func waitResult(ch <-chan int) int {
    return <-ch
}

生产环境这种代码就是定时炸弹------上游一旦不响应,这个 goroutine 就永远挂在这里,连带上游的资源也释放不掉。正确做法是用 select 配一个 time.After:

go 复制代码

import "time"

func waitResult(ch <-chan int) (int, error) {
    select {
    case v := <-ch:
        return v, nil
    case <-time.After(2 * time.Second):
        // 超过 2 秒没结果就返回错误,不再干等
        return 0, fmt.Errorf("timeout waiting for result")
    }
}

time.After(d) 返回一个 channel,d 时间后会往里塞一个值。select 会同时监听结果 channel 和这个定时 channel,哪个先来走哪个。

一个坑 :time.After 在超时前不会被 GC 回收。如果你在一个高频循环里用它,会短暂堆积大量 Timer。循环内的超时应改用 time.NewTimer 并手动 Stop:

go 复制代码

func waitResultLoop(ch <-chan int) {
    timer := time.NewTimer(2 * time.Second)
    defer timer.Stop() // 用完及时释放,避免 Timer 堆积
    select {
    case v := <-ch:
        fmt.Println(v)
    case <-timer.C:
        fmt.Println("timeout")
    }
}

套路二:非阻塞收发

有时你不想等,只想「试一下,能读就读,不能读就算了」。关键是给 select 加一个 default 分支------只要有 default,select 就永远不会阻塞。

go 复制代码

// 非阻塞读:channel 里有数据就拿,没有就走 default
func tryRead(ch <-chan int) {
    select {
    case v := <-ch:
        fmt.Println("got:", v)
    default:
        fmt.Println("nothing ready, skip")
    }
}

// 非阻塞写:channel 满了就丢弃,不阻塞生产者
func trySend(ch chan<- int, v int) bool {
    select {
    case ch <- v:
        return true
    default:
        return false // 缓冲满了,主动丢弃(比如做限流/降级)
    }
}

非阻塞写在实战里特别有用:比如做一个「有界的事件上报队列」,队列满了宁可丢事件也不能阻塞主流程,trySend 就是标准写法。

套路三:优雅退出 goroutine

启动了 goroutine 却没法通知它退出,是 Go 里最常见的泄漏源。标准解法是用一个 done channel(或 context)配 select:

go 复制代码

func worker(jobs <-chan int, done <-chan struct{}) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-done:
            // 收到退出信号,清理后返回,goroutine 正常结束
            fmt.Println("worker exiting")
            return
        }
    }
}

func main() {
    jobs := make(chan int)
    done := make(chan struct{})

    go worker(jobs, done)

    jobs <- 1
    jobs <- 2

    close(done) // 关闭 done,所有监听它的 select 都会立刻收到零值
    time.Sleep(100 * time.Millisecond) // 等 worker 打印退出(实际用 WaitGroup)
}

func process(n int) { fmt.Println("processing", n) }

这里的精髓是 close(done) 而不是往里发值 :关闭 channel 后,所有从它读取的 select 分支都会立刻返回(读到零值),所以能一次性通知任意数量的 goroutine 退出,不用给每个 goroutine 单独发信号。

实际项目里更推荐直接用 context.Context,它就是把这套 done channel 封装好了,还能级联取消:

go 复制代码

func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():
            return // ctx 被 cancel 或超时,退出
        }
    }
}

小结

超时 :select + time.After,别裸读 channel;循环里改用 time.NewTimer + Stop 避免 Timer 堆积。
非阻塞 :加 default 分支,select 就永不阻塞,适合做「能读就读、队满就丢」的降级逻辑。
优雅退出 :select 监听 done/ctx.Done(),用 close(done) 一次性通知所有 goroutine 退出,避免泄漏。

一句话记忆:select 不只是「多路复用」,time.After、default、done 三个搭配才是它在生产环境的真正价值------分别对应「不干等」「不阻塞」「能收场」。