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)

  1. Direct Send(直接发送/零拷贝):如果 recvq 等待队列不为空,说明有 Goroutine 在等数据。此时绕过 buf,直接将数据从发送方的栈复制到接收方 Goroutine 的栈空间,并唤醒该接收协程(goroutine 状态由 Gwaiting $\to$ Grunnable)。
  2. 写入缓冲区:如果 buf 没满,将数据写入 buf[sendx],游标 sendx++。
  3. 阻塞等待:如果 buf 已满(或无缓冲),当前 Goroutine 会被打包成 sudog 挂载到 sendq 队列末尾,随后调用 gopark 让出 CPU 进入休眠。

② 接收数据(v <- ch)

  1. Direct Recv:如果 sendq 等待队列不为空,说明有协程卡在发送上:
    • 若是无缓冲 Channel:直接从发送方栈复制数据到接收方。
    • 若是有缓冲 Channel:从 buf 头拿数据,再把 sendq 队头的发送数据补充进 buf。
  2. 读取缓冲区:如果 buf 有数据,直接从 buf[recvx] 取出,游标 recvx++。
  3. 阻塞等待:如果 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 回收即可。”