Golang Channel 原理
Golang Channel 原理
channel 的底层结构
一把锁 一个环形数组(可选) 两个等待队列(sendq / recvq)
type hchan struct {
qcount uint // 当前队列中元素个数
dataqsiz uint // 环形缓冲区大小
buf unsafe.Pointer // 指向环形数组
elemsize uint16
closed uint32
sendx uint // 发送索引
recvx uint // 接收索引
recvq waitq // 等待接收的 goroutine 队列
sendq waitq // 等待发送的 goroutine 队列
lock mutex
}
**sudog **的底层结构
保存 goroutine
保存发送数据地址
type sudog struct {
g *g
elem unsafe.Pointer
}
代码
// 位于 src/runtime/chan.go
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
// 1. 特判:nil channel
if c == nil {
if !block { return false }
gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2) // 永久休眠
}
lock(&c.lock) // 加锁
// 2. 特判:向已关闭的 channel 发送数据 -> 直接 panic
if c.closed != 0 {
unlock(&c.lock)
panic(plainError("send on closed channel"))
}
// 分支一:直接发送 (Direct Send)
// 如果 recvq 队列里有等待接收的 G,直接把数据拷贝给它,省去写 buf 的开销
if sg := c.recvq.dequeue(); sg != nil {
send(c, sg, ep, func() { unlock(&c.lock) }, 2)
return true
}
// 分支二:写入环形缓冲区 (buf)
// 如果缓冲区还有空位 (qcount < dataqsiz)
if c.qcount < c.dataqsiz {
qp := chanbuf(c, c.sendx) // 获取 sendx 游标对应的内存指针
typedmemmove(c.elemtype, qp, ep) // 将数据拷入 buf
c.sendx++
if c.sendx == c.dataqsiz { c.sendx = 0 } // 环形游标重置
c.qcount++
unlock(&c.lock)
return true
}
// 分支三:阻塞等待
// buf 满了或者无缓冲:将当前 G 打包为 sudog 挂载到 sendq,然后休眠
gp := getg()
mysg := acquireSudog()
mysg.elem = ep
mysg.g = gp
c.sendq.enqueue(mysg) // 入队
gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2) // 解锁并挂起 G
// 唤醒后的清理工作
releaseSudog(mysg)
return true
}
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
// 1. 特判:从 nil channel 接收数据
if c == nil {
if !block { return false, false }
gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2) // 永久休眠
}
lock(&c.lock) // 加锁
// 2. 特判:Channel 已关闭,且 buf 中没有残留数据
if c.closed != 0 && c.qcount == 0 {
unlock(&c.lock)
if ep != nil {
typedmemclr(c.elemtype, ep) // 内存清零,返回类型的零值
}
return true, false // received 为 false,即 v, ok 中的 ok = false
}
// 分支一:直接接收 (Direct Receive)
// 如果 sendq 队列里有阻塞的发送方 G
if sg := c.sendq.dequeue(); sg != nil {
recv(c, sg, ep, func() { unlock(&c.lock) }, 2)
return true, true
}
// 分支二:从环形缓冲区 (buf) 读取
if c.qcount > 0 {
qp := chanbuf(c, c.recvx)
if ep != nil {
typedmemmove(c.elemtype, ep, qp) // 将数据从 buf 拷贝给接收方
}
typedmemclr(c.elemtype, qp) // 清空 buf 原位置
c.recvx++
if c.recvx == c.dataqsiz { c.recvx = 0 } // 环形游标重置
c.qcount--
unlock(&c.lock)
return true, true
}
// 分支三:阻塞等待
// buf 为空:将当前 G 打包挂载到 recvq,随后休眠
gp := getg()
mysg := acquireSudog()
mysg.elem = ep
mysg.g = gp
c.recvq.enqueue(mysg) // 入队
gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockReceive, 2) // 解锁并挂起 G
// 唤醒后的清理工作
releaseSudog(mysg)
return true, true
}
① 发送数据(ch <- v)
- Direct Send(直接发送/零拷贝):如果
recvq等待队列不为空,说明有 Goroutine 在等数据。此时绕过buf,直接将数据从发送方的栈复制到接收方 Goroutine 的栈空间,并唤醒该接收协程(goroutine状态由Gwaiting$\to$Grunnable)。 - 写入缓冲区:如果
buf没满,将数据写入buf[sendx],游标sendx++。 - 阻塞等待:如果
buf已满(或无缓冲),当前 Goroutine 会被打包成sudog挂载到sendq队列末尾,随后调用gopark让出 CPU 进入休眠。
② 接收数据(v <- ch)
- Direct Recv:如果
sendq等待队列不为空,说明有协程卡在发送上:- 若是无缓冲 Channel:直接从发送方栈复制数据到接收方。
- 若是有缓冲 Channel:从
buf头拿数据,再把sendq队头的发送数据补充进buf。
- 读取缓冲区:如果
buf有数据,直接从buf[recvx]取出,游标recvx++。 - 阻塞等待:如果
buf为空,当前 Goroutine 打包挂进recvq并休眠(gopark)。
close
func closechan(c *hchan) {
// 上锁
lock(&c.lock)
// 如果 channel 已经关闭
if c.closed != 0 {
unlock(&c.lock)
// panic
panic(plainError("close of closed channel"))
}
// 修改关闭状态
c.closed = 1
var glist *g
// 将 channel 所有等待接收队列的里 sudog 释放
for {
// 从接收队列里出队一个 sudog
sg := c.recvq.dequeue()
// 出队完毕,跳出循环
if sg == nil {
break
}
// 给它赋一个相应类型的零值
if sg.elem != nil {
typedmemclr(c.elemtype, sg.elem)
sg.elem = nil
}
// 取出 goroutine
gp := sg.g
gp.param = nil
if raceenabled {
raceacquireg(gp, unsafe.Pointer(c))
}
// 相连,形成链表
gp.schedlink.set(glist)
glist = gp
}
// 将 channel 等待发送队列里的 sudog 释放
// 如果存在,这些 goroutine 将会 panic
for {
// 从发送队列里出队一个 sudog
sg := c.sendq.dequeue()
if sg == nil {
break
}
// 发送者会 panic
sg.elem = nil
if sg.releasetime != 0 {
sg.releasetime = cputicks()
}
gp := sg.g
gp.param = nil
if raceenabled {
raceacquireg(gp, unsafe.Pointer(c))
}
// 形成链表
gp.schedlink.set(glist)
glist = gp
}
// 解锁
unlock(&c.lock)
// Ready all Gs now that we've dropped the channel lock.
// 遍历链表
for glist != nil {
// 取最后一个
gp := glist
// 向前走一步,下一个唤醒的 g
glist = glist.schedlink.ptr()
gp.schedlink = 0
// 唤醒相应 goroutine
goready(gp, 3)
}
}
广播所有的接收者和发送者
对于接收者:会收到一个相应类型的零值
等待发送者: 会执行代码 if c.closed != 0panic(“send on closed channel”),会报错
三大异常场景与避坑法则
| 操作 | 未初始化(nil channel) | 已关闭(closed channel) | 正常 Channel |
|---|---|---|---|
读(<-ch) |
永久阻塞(导致死锁/泄漏) | 读完剩余数据后,返回零值(配合 v, ok := <-ch 判别) |
正常读取,无数据则阻塞 |
写(ch <- v) |
永久阻塞(导致死锁/泄漏) | panic: send on closed channel | 正常写入,缓冲区满则阻塞 |
关闭(close) |
panic: close of nil channel | panic: close of closed channel | 正常关闭,唤醒所有等待者 |
Q1: Channel 的优雅关闭原则(Channel Close Principle)?
- 原则:永远不要在接收端关闭 Channel,也永远不要在有多个并发发送端时关闭 Channel。
- 正确姿势:
- “在 Go 中优雅关闭 Channel 的核心思想是‘不要强行关闭数据 Channel,而是通过关闭一个额外的信号 Channel(
stopCh)来进行广播退出的通知’。- 如果是 1 个发送者,直接由发送者
close(ch)。 - 如果是 多个发送者,永远不要在接收端或任意发送端直接关闭数据 Channel。应该借助
select监听stopCh的关闭事件,利用 Go 语言关闭通道时会向所有接收者广播零值的特性,让所有相关 Goroutine 自动安全退出,而数据 Channel 本身交由 GC 回收即可。”
- 如果是 1 个发送者,直接由发送者