Go Channel 与 select
goroutine 让代码并发跑起来,channel 负责让 goroutine 之间说话。
创建一个 channel:
ch := make(chan string)这个 ch 只能传 string。
<- 是什么
<- 是 channel 的收发语法。
发送:
ch <- "hello"意思是把 "hello" 放进 ch。
接收:
msg := <-ch意思是从 ch 里取一个值,赋给 msg。
只接收、不关心值:
<-ch这种经常用来等一个信号。
比如:
case <-ctx.Done(): return它不是为了拿到什么业务数据,只是等 context 被取消。
无缓冲 channel
默认创建的是无缓冲 channel:
ch := make(chan string)无缓冲 channel 要求发送和接收同时出现。
func main() { ch := make(chan string)
go func() { ch <- "hello" }()
msg := <-ch fmt.Println(msg)}后台 goroutine 发送,main goroutine 接收,所以能跑。
如果只有发送,没有接收:
func main() { ch := make(chan string) ch <- "hello"}会死锁。
如果只有接收,没有发送:
func main() { ch := make(chan string) msg := <-ch fmt.Println(msg)}也会死锁。
无缓冲 channel 很像一次当面交接:你给的时候,必须有人接。
有缓冲 channel
有缓冲 channel 创建时带容量:
ch := make(chan string, 2)它可以先放两个值:
ch <- "A"ch <- "B"第三个值会阻塞,除非有人先取走一个:
ch <- "C"有缓冲 channel 像一个小队列。它能让发送方和接收方的节奏稍微错开。
比如流式输出:
events := make(chan StreamEvent, 64)模型返回事件可能很快,UI 渲染可能慢一点。给 64 个缓冲,生产者不用每发一个事件都立刻等消费者。
但缓冲不是无限的。消费者一直不读,缓冲满了以后,发送方照样会阻塞。
用 chan bool 做一把简单的锁
channel 也可以拿来做“锁”的效果。
比如用容量为 1 的 chan bool:
lock := make(chan bool, 1)加锁:
lock <- true解锁:
<-lock完整例子:
func main() { lock := make(chan bool, 1) count := 0
var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func() { defer wg.Done()
lock <- true count++ <-lock }() }
wg.Wait() fmt.Println(count)}为什么它像锁?
因为 lock 容量只有 1。第一个 goroutine 写入成功后,其他 goroutine 再执行:
lock <- true就会阻塞。只有前一个 goroutine 执行:
<-lock把位置让出来,下一个 goroutine 才能进去。
实际项目里,普通互斥优先用 sync.Mutex,表达更直接:
var mu sync.Mutexmu.Lock()defer mu.Unlock()chan bool 这种写法适合理解 channel 的阻塞机制,也适合做简单的并发限制。
close
发送方可以关闭 channel:
close(ch)关闭不是删除 channel,而是告诉接收方:后面不会再有新数据了。
接收时可以拿到两个值:
v, ok := <-chok == false 表示 channel 已经关闭,并且没有剩余数据。
更常用的是 for range:
for msg := range ch { fmt.Println(msg)}当 channel 关闭,并且里面的数据都读完,循环会结束。
发送方关闭,接收方不要关。
原因也简单:发送方才知道自己还会不会继续发。
重复关闭 channel 会 panic:
close(ch)close(ch) // panic单向 channel
函数参数可以限制 channel 方向。
只发送:
func producer(out chan<- int) { out <- 1}只接收:
func consumer(in <-chan int) { v := <-in fmt.Println(v)}这不是必须写,但写了以后意图更清楚。编译器也能帮你挡住一部分误用。
比如 consumer 里不能发送:
in <- 1 // 编译不过select
select 用来同时等多个 channel。
select {case msg := <-ch: fmt.Println("message:", msg)case <-time.After(time.Second): fmt.Println("timeout")}哪个 case 先准备好,就执行哪个。
如果都没准备好,select 会阻塞。
如果多个 case 同时准备好,Go 会随机选一个。
default
加了 default,select 就不会阻塞。
select {case msg := <-ch: fmt.Println(msg)default: fmt.Println("no message")}如果 ch 没数据,直接走 default。
这个适合“试一下”的场景。不要为了看起来完整就乱加 default。很多时候,我们就是希望 goroutine 等在那里。
context.Done
context.Context 常用来通知取消。
ctx, cancel := context.WithCancel(context.Background())defer cancel()调用:
cancel()之后,ctx.Done() 会关闭。
所以可以这么写:
select {case <-ctx.Done(): return ctx.Err()}ctx.Done() 本质上也是一个 channel。我们从里面接收,不是为了拿数据,而是为了知道“该停了”。
用 channel 改写等待
假设有一个很慢的函数:
func slow() string { time.Sleep(2 * time.Second) return "done"}直接调用会卡住:
result := slow()fmt.Println(result)如果希望同时支持超时,可以把结果送进 channel:
ch := make(chan string, 1)
go func() { ch <- slow()}()
select {case result := <-ch: fmt.Println(result)case <-time.After(time.Second): fmt.Println("timeout")}这里后台 goroutine 等 slow(),主 goroutine 等两个信号:结果或超时。
SSE 流式读取里的用法
LLM 流式响应里,经常会有类似:
stream.Next()它的意思是:等服务端发来下一条事件。
问题在于,它可能阻塞很久。服务端一直不发,或者连接静默挂住,它就不返回。
如果直接写:
for stream.Next() { // 处理事件}一旦 stream.Next() 卡住,当前 goroutine 就没机会处理取消和超时。
所以可以这样拆:
readNext := func() { nextCh <- sseResult{ hasNext: stream.Next(), }}
go readNext()后台 goroutine 负责卡在 stream.Next()。
主 goroutine 用 select:
select {case <-ctx.Done(): return ctx.Err()case <-idle.C: return errors.New("stream timeout")case res := <-nextCh: _ = res}这样主 goroutine 同时等三件事:
- 用户取消
- 空闲超时
- 下一条事件到了
收到一次 nextCh 的结果后,再启动下一次读取:
go readNext()注意不是一次开很多个 readNext。同一个 stream 通常应该一个一个读,否则顺序会乱,SDK 内部也未必支持并发读。
记法
channel 代码先问四个问题:
- 谁发?
- 谁收?
- 谁关?
- 满了或空了会不会卡住?
select 代码再问两个问题:
- 我是不是要同时等多个信号?
- 要不要支持取消或超时?
把这几个问题想清楚,channel 就不会只是背语法了。
分享文章
生成精美分享图或复制链接,与更多人分享本文。
继续阅读
换条路线
从其他文章中稳定抽取
最后更新于 ,距今已过 107 天
部分内容可能已过时