源码分析

发送操作最终转化为 chansend 函数，直接上源码，同样大部分都注释了，可以看懂主流程：

  1. // 位于 src/runtime/chan.go
  3. func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
  4.     // 如果 channel 是 nil
  5.     if c == nil {
  6.         // 不能阻塞，直接返回 false，表示未发送成功
  7.         if !block {
  8.             return false
  9.         }
  10.         // 当前 goroutine 被挂起
  11.         gopark(nil, nil, "chan send (nil chan)", traceEvGoStop, 2)
  12.         throw("unreachable")
  13.     }
  15.     // 省略 debug 相关……
  17.     // 对于不阻塞的 send，快速检测失败场景
  18.     //
  19.     // 如果 channel 未关闭且 channel 没有多余的缓冲空间。这可能是：
  20.     // 1. channel 是非缓冲型的，且等待接收队列里没有 goroutine
  21.     // 2. channel 是缓冲型的，但循环数组已经装满了元素
  22.     if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) ||
  23.         (c.dataqsiz > 0 && c.qcount == c.dataqsiz)) {
  24.         return false
  25.     }
  27.     var t0 int64
  28.     if blockprofilerate > 0 {
  29.         t0 = cputicks()
  30.     }
  32.     // 锁住 channel，并发安全
  33.     lock(&c.lock)
  35.     // 如果 channel 关闭了
  36.     if c.closed != 0 {
  37.         // 解锁
  38.         unlock(&c.lock)
  39.         // 直接 panic
  40.         panic(plainError("send on closed channel"))
  41.     }
  43.     // 如果接收队列里有 goroutine，直接将要发送的数据拷贝到接收 goroutine
  44.     if sg := c.recvq.dequeue(); sg != nil {
  45.         send(c, sg, ep, func() { unlock(&c.lock) }, 3)
  46.         return true
  47.     }
  49.     // 对于缓冲型的 channel，如果还有缓冲空间
  50.     if c.qcount < c.dataqsiz {
  51.         // qp 指向 buf 的 sendx 位置
  52.         qp := chanbuf(c, c.sendx)
  54.         // ……
  56.         // 将数据从 ep 处拷贝到 qp
  57.         typedmemmove(c.elemtype, qp, ep)
  58.         // 发送游标值加 1
  59.         c.sendx++
  60.         // 如果发送游标值等于容量值，游标值归 0
  61.         if c.sendx == c.dataqsiz {
  62.             c.sendx = 0
  63.         }
  64.         // 缓冲区的元素数量加一
  65.         c.qcount++
  67.         // 解锁
  68.         unlock(&c.lock)
  69.         return true
  70.     }
  72.     // 如果不需要阻塞，则直接返回错误
  73.     if !block {
  74.         unlock(&c.lock)
  75.         return false
  76.     }
  78.     // channel 满了，发送方会被阻塞。接下来会构造一个 sudog
  80.     // 获取当前 goroutine 的指针
  81.     gp := getg()
  82.     mysg := acquireSudog()
  83.     mysg.releasetime = 0
  84.     if t0 != 0 {
  85.         mysg.releasetime = -1
  86.     }
  88.     mysg.elem = ep
  89.     mysg.waitlink = nil
  90.     mysg.g = gp
  91.     mysg.selectdone = nil
  92.     mysg.c = c
  93.     gp.waiting = mysg
  94.     gp.param = nil
  96.     // 当前 goroutine 进入发送等待队列
  97.     c.sendq.enqueue(mysg)
  99.     // 当前 goroutine 被挂起
  100.     goparkunlock(&c.lock, "chan send", traceEvGoBlockSend, 3)
  102.     // 从这里开始被唤醒了（channel 有机会可以发送了）
  103.     if mysg != gp.waiting {
  104.         throw("G waiting list is corrupted")
  105.     }
  106.     gp.waiting = nil
  107.     if gp.param == nil {
  108.         if c.closed == 0 {
  109.             throw("chansend: spurious wakeup")
  110.         }
  111.         // 被唤醒后，channel 关闭了。坑爹啊，panic
  112.         panic(plainError("send on closed channel"))
  113.     }
  114.     gp.param = nil
  115.     if mysg.releasetime > 0 {
  116.         blockevent(mysg.releasetime-t0, 2)
  117.     }
  118.     // 去掉 mysg 上绑定的 channel
  119.     mysg.c = nil
  120.     releaseSudog(mysg)
  121.     return true
  122. }

上面的代码注释地比较详细了，我们来详细看看。

  • 如果检测到 channel 是空的，当前 goroutine 会被挂起。

  • 对于不阻塞的发送操作，如果 channel 未关闭并且没有多余的缓冲空间（说明：a. channel 是非缓冲型的，且等待接收队列里没有 goroutine；b. channel 是缓冲型的，但循环数组已经装满了元素）

对于这一点，runtime 源码里注释了很多。这一条判断语句是为了在不阻塞发送的场景下快速检测到发送失败，好快速返回。

  1. if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) || (c.dataqsiz > 0 && c.qcount == c.dataqsiz)) {
  2.     return false
  3. }

注释里主要讲为什么这一块可以不加锁，我详细解释一下。if 条件里先读了两个变量：block 和 c.closed。block 是函数的参数，不会变；c.closed 可能被其他 goroutine 改变，因为没加锁嘛，这是“与”条件前面两个表达式。

最后一项，涉及到三个变量：c.dataqsiz，c.recvq.first，c.qcount。c.dataqsiz == 0 && c.recvq.first == nil 指的是非缓冲型的 channel，并且 recvq 里没有等待接收的 goroutine；c.dataqsiz > 0 && c.qcount == c.dataqsiz 指的是缓冲型的 channel，但循环数组已经满了。这里 c.dataqsiz 实际上也是不会被修改的，在创建的时候就已经确定了。不加锁真正影响地是 c.qcount 和 c.recvq.first。

这一部分的条件就是两个 word-sized read，就是读两个 word 操作：c.closed 和 c.recvq.first（非缓冲型） 或者 c.qcount（缓冲型）。

当我们发现 c.closed == 0 为真，也就是 channel 未被关闭，再去检测第三部分的条件时，观测到 c.recvq.first == nil 或者 c.qcount == c.dataqsiz 时（这里忽略 c.dataqsiz），就断定要将这次发送操作作失败处理，快速返回 false。

这里涉及到两个观测项：channel 未关闭、channel not ready for sending。这两项都会因为没加锁而出现观测前后不一致的情况。例如我先观测到 channel 未被关闭，再观察到 channel not ready for sending，这时我以为能满足这个 if 条件了，但是如果这时 c.closed 变成 1，这时其实就不满足条件了，谁让你不加锁呢！

但是，因为一个 closed channel 不能将 channel 状态从 ‘ready for sending’ 变成 ‘not ready for sending’，所以当我观测到 ‘not ready for sending’ 时，channel 不是 closed。即使 c.closed == 1，即 channel 是在这两个观测中间被关闭的，那也说明在这两个观测中间，channel 满足两个条件：not closed 和 not ready for sending，这时，我直接返回 false 也是没有问题的。

这部分解释地比较绕，其实这样做的目的就是少获取一次锁，提升性能。

  • 如果检测到 channel 已经关闭，直接 panic。

  • 如果能从等待接收队列 recvq 里出队一个 sudog（代表一个 goroutine），说明此时 channel 是空的，没有元素，所以才会有等待接收者。这时会调用 send 函数将元素直接从发送者的栈拷贝到接收者的栈，关键操作由 sendDirect 函数完成。

  1. // send 函数处理向一个空的 channel 发送操作
  3. // ep 指向被发送的元素，会被直接拷贝到接收的 goroutine
  4. // 之后，接收的 goroutine 会被唤醒
  5. // c 必须是空的（因为等待队列里有 goroutine，肯定是空的）
  6. // c 必须被上锁，发送操作执行完后，会使用 unlockf 函数解锁
  7. // sg 必须已经从等待队列里取出来了
  8. // ep 必须是非空，并且它指向堆或调用者的栈
  10. func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
  11.     // 省略一些用不到的
  12.     // ……
  14.     // sg.elem 指向接收到的值存放的位置，如 val <- ch，指的就是 &val
  15.     if sg.elem != nil {
  16.         // 直接拷贝内存（从发送者到接收者）
  17.         sendDirect(c.elemtype, sg, ep)
  18.         sg.elem = nil
  19.     }
  20.     // sudog 上绑定的 goroutine
  21.     gp := sg.g
  22.     // 解锁
  23.     unlockf()
  24.     gp.param = unsafe.Pointer(sg)
  25.     if sg.releasetime != 0 {
  26.         sg.releasetime = cputicks()
  27.     }
  28.     // 唤醒接收的 goroutine. skip 和打印栈相关，暂时不理会
  29.     goready(gp, skip+1)
  30. }

继续看 sendDirect 函数：

  1. // 向一个非缓冲型的 channel 发送数据、从一个无元素的（非缓冲型或缓冲型但空）的 channel
  2. // 接收数据，都会导致一个 goroutine 直接操作另一个 goroutine 的栈
  3. // 由于 GC 假设对栈的写操作只能发生在 goroutine 正在运行中并且由当前 goroutine 来写
  4. // 所以这里实际上违反了这个假设。可能会造成一些问题，所以需要用到写屏障来规避
  5. func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
  6.     // src 在当前 goroutine 的栈上，dst 是另一个 goroutine 的栈
  8.     // 直接进行内存"搬迁"
  9.     // 如果目标地址的栈发生了栈收缩，当我们读出了 sg.elem 后
  10.     // 就不能修改真正的 dst 位置的值了
  11.     // 因此需要在读和写之前加上一个屏障
  12.     dst := sg.elem
  13.     typeBitsBulkBarrier(t, uintptr(dst), uintptr(src), t.size)
  14.     memmove(dst, src, t.size)
  15. }

这里涉及到一个 goroutine 直接写另一个 goroutine 栈的操作，一般而言，不同 goroutine 的栈是各自独有的。而这也违反了 GC 的一些假设。为了不出问题，写的过程中增加了写屏障，保证正确地完成写操作。这样做的好处是减少了一次内存 copy：不用先拷贝到 channel 的 buf，直接由发送者到接收者，没有中间商赚差价，效率得以提高，完美。

然后，解锁、唤醒接收者，等待调度器的光临，接收者也得以重见天日，可以继续执行接收操作之后的代码了。

  • 如果 c.qcount < c.dataqsiz，说明缓冲区可用（肯定是缓冲型的 channel）。先通过函数取出待发送元素应该去到的位置：
  1. qp := chanbuf(c, c.sendx)
  3. // 返回循环队列里第 i 个元素的地址处
  4. func chanbuf(c *hchan, i uint) unsafe.Pointer {
  5.     return add(c.buf, uintptr(i)*uintptr(c.elemsize))
  6. }

c.sendx 指向下一个待发送元素在循环数组中的位置，然后调用 typedmemmove 函数将其拷贝到循环数组中。之后 c.sendx 加 1，元素总量加 1 ：c.qcount++，最后，解锁并返回。

  • 如果没有命中以上条件的，说明 channel 已经满了。不管这个 channel 是缓冲型的还是非缓冲型的，都要将这个 sender “关起来”（goroutine 被阻塞）。如果 block 为 false，直接解锁，返回 false。

  • 最后就是真的需要被阻塞的情况。先构造一个 sudog，将其入队（channel 的 sendq 字段）。然后调用 goparkunlock 将当前 goroutine 挂起，并解锁，等待合适的时机再唤醒。

唤醒之后，从 goparkunlock 下一行代码开始继续往下执行。

这里有一些绑定操作，sudog 通过 g 字段绑定 goroutine，而 goroutine 通过 waiting 绑定 sudog，sudog 还通过 elem 字段绑定待发送元素的地址，以及 c 字段绑定被“坑”在此处的 channel。

所以，待发送的元素地址其实是存储在 sudog 结构体里，也就是当前 goroutine 里。

案例分析

好了，看完源码。我们接着来分析例子，代码如下：

  1. func goroutineA(a <-chan int) {
  2.     val := <- a
  3.     fmt.Println("goroutine A received data: ", val)
  4.     return
  5. }
  7. func goroutineB(b <-chan int) {
  8.     val := <- b
  9.     fmt.Println("goroutine B received data: ", val)
  10.     return
  11. }
  13. func main() {
  14.     ch := make(chan int)
  15.     go goroutineA(ch)
  16.     go goroutineB(ch)
  17.     ch <- 3
  18.     time.Sleep(time.Second)
  20.     ch1 := make(chan struct{})
  21. }

在发送小节里我们说到 G1 和 G2 现在被挂起来了，等待 sender 的解救。在第 17 行，主协程向 ch 发送了一个元素 3，来看下接下来会发生什么。

根据前面源码分析的结果，我们知道，sender 发现 ch 的 recvq 里有 receiver 在等待着接收，就会出队一个 sudog，把 recvq 里 first 指针的 sudo “推举”出来了，并将其加入到 P 的可运行 goroutine 队列中。

然后，sender 把发送元素拷贝到 sudog 的 elem 地址处，最后会调用 goready 将 G1 唤醒，状态变为 runnable。

G1 runnable

当调度器光顾 G1 时，将 G1 变成 running 状态，执行 goroutineA 接下来的代码。G 表示其他可能有的 goroutine。

这里其实涉及到一个协程写另一个协程栈的操作。有两个 receiver 在 channel 的一边虎视眈眈地等着，这时 channel 另一边来了一个 sender 准备向 channel 发送数据，为了高效，用不着通过 channel 的 buf “中转”一次，直接从源地址把数据 copy 到目的地址就可以了，效率高啊！

send direct

上图是一个示意图，3 会被拷贝到 G1 栈上的某个位置，也就是 val 的地址处，保存在 elem 字段。

参考资料

【深入 channel 底层】https://codeburst.io/diving-deep-into-the-golang-channels-549fd4ed21a8

【Kavya在Gopher Con 上关于 channel 的设计，非常好】https://speakerd.s3.amazonaws.com/presentations/10ac0b1d76a6463aa98ad6a9dec917a7/GopherCon_v10.0.pdf