Don't communicate by sharing memory, share memory by communicating.

不要通过共享内存来通信，而要通过通信来实现内存共享。

数据结构

我们可以把 Channel 看做是一个先进先出(FIFO)的数据队列，那么如何实现这种队列

channel 的底层数据结构是一个 *hchan，在编译时期会将 make(chan int) 语句转换成 makechan 函数调用

hchan

// runtime/chan.go
type hchan struct {
    lock mutex  // lock 用来保护 hchan 上所有的字段
    
    // 缓冲区实际是一个循环队列
    buf unsafe.Pointer  // 指向缓冲区的指针
    dataqsiz uint   // 缓冲区循环队列的大小
    sendx uint      // 缓冲区循环队列接收下一个元素的索引
    recvx uint      //  缓冲区循环队列中下一个会返回的元素的索引
    
    qcount uint // 当前 hchan 缓存的元素数量
    closed uint32   // hchan 是否关闭
    
    elemsize uint16 // hchan 的元素大小
    elemtype *_type // hchan 的元素类型
    
    recvq waitq     // 等待接收的 goroutine 队列
    sendq waitq     // 等待发送的 goroutine 队列
}

可以看出 channel 的底层数据结构

• 缓冲区 buf 底层是一个循环队列，dataqsiz 和 qcount 分别记录了缓冲区的大小和当前缓冲的元素数量，sendx，recvx 用来记录位置索引
• elemsize 和 elemtype 表示元素大小和类型
• recvq 和 sendq 来记录被发送接收阻塞的 goroutine 队列
• closed 用来记录是否关闭
• lock 用来保护hchan中的字段，更新其他字段的时候都需要加锁

对于无缓冲 channel 是不需要和缓冲区相关的字段的

channel 在实现中依然使用到了锁，Go 所说的 使用通信来实现共享内存，实际上依然在底层使用锁来保证读写的原子性，实现出了一个面向数据流式的数据结构

待发送者和待接收者

注意到 recvq 和 sendq 类型 waitq 是一个双向链表，提供了等待 goroutine 的出队入队

// runtime/chan.go
type waitq struct {
    first *sudog
    last * sudog
}

func(q *waitq) enqueue(sgp *sudog){
// ...
}
func (q *waitq) dequeue(sgp *sudog){
// ...
}

sudog 是对被阻塞的 goroutine 的封装，简单看一下 channel 会使用到的一些字段

// runtime/runtime2.go
type sudog struct {
    g       *g              //阻塞的 goroutine
    elem    unsafe.Pointer
    c       *hchan          // 阻塞的 channel

elem 字段是一个指针，在 channel 会被用来指向待发送者要发送的数据或者待接收者的接收位置

// 从 ch 接收数据被阻塞，那么 sudog.elem 会指向 x
x <- ch 

// 向 ch 发送数据被阻塞，那么 sudog.elem 会指向 y
ch <- y 

makechan 创建 channel

channel 分为无缓冲 channel 和 缓冲 channel，虽然两种 channel 的创建方式不同，但是都是调用 makechan

ch := make(chan int)    // 无缓冲 channel
    
ch := make(chan int, 10)// 有缓冲 channel

makechan 函数会接受元素的类型和缓冲的大小，如果 size 为 0，就是无缓冲 channel 了

// src/runtime/chan.go
func makechan(t *chantype, size int) *hchan{
    elem := t.elem
    
    // 检查 elem size，align
    
    // 计算出缓冲区的大小，如果是非缓冲 channel 或者元素为 struct{}，那么 mem 就是 0
    mem, overflow := math.MulUintptr(elem.size, uintptr(size))
    if overflow || mem > maxAlloc-hchanSize || size < 0{
        panic(plainError("makechan: size out of range"))
    }
    
    var c *hchan
    switch{
    // 非缓冲 channel 或者 缓冲区元素 为 struct{}
    case mem == 0:
        c = (*hchan)(mallocgc(hchanSize, nil, true))
        // 如果是非缓冲，则buf并没有用
        // 如果缓冲元素类型为 struct{}, 则只会用到 sendx 和 recvx, 并不会真正拷贝数据到缓冲区
        c.buf = unsafe.Pointer(&c.buf)
        
    // channel 中元素不包含指针
    case elem.ptrdata == 0:
        // 将 hchan 结构和缓冲区的内存一起分配
        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
        // buf 指向 hchan 后边的地址
        c.buf = add(unsafe.Pointer(c), hchanSize)
        
    // 默认，分别分配 chan 和 buf 的内存    
    default:
        c = new(hchan)
        c.buf = mallocgc(mem, elem, true)
    }
    
    // 设置 hchan 的其他字段
    c.elemsize = uint16(elem.size)
    c.elemtype = elem
    // 底层循环队列长度
    c.datasiz = uint(size)
    return c

通过 makechan 函数，可以总结出 hchan 结构的特点

• 无缓冲或者缓冲的元素类型为 struct{} 时，并不会为缓冲区（hcha.buf）分配内存
• 缓冲的元素结构中不包含指针时，会将 hchan 和 缓冲区buf 是一块连续的内存

make 与 makechan

make 函数在编译阶段又是如何转换成 makechan 函数调用的呢

首先编译器会将 make 的调用转换成 OMAKE 类型的节点，然后判断 make 的对象类型，如果是 TCHAN 的话，将节点类型置为 OMAKECHAN，并且检查 make 的第二个参数，也就是缓冲区大小

// src/cmd/compile/internal/gc/typecheck.go
func typecheck1(n *Node, top int) (res *Node) {
    // ...
    switch n.Op{
    case OMAKE:
        switch t.Etype {
        case TCHAN:
            l = nil
            if i < len(args){
                // ... 对缓冲区大小进行检测
                n.Left = l  // 带缓冲区，赋值缓冲区大小
            }else{
                n.Left = nodintconst(0) // 不带缓冲区
            }
            n.Op = OMAKECHAN
        }
    }
}

然后OMAKECHAN 节点会在 walkexpr 函数中转换成调用 makechan 或者 makechan64 函数

// src/cmd/compile/internal/gc/walk.go
func walkexpr(n *Node, init *Nodes) *Node {
    switch n.Op {
    case OMAKECHAN:
        size := n.Left
        fnname := "makechan64"
        argtype := types.Types[TINT64]

        if size.Type.IsKind(TIDEAL) || maxintval[size.Type.Etype].Cmp(maxintval[TUINT]) <= 0 {
            fnname = "makechan"
            argtype = types.Types[TINT]
        }
        n = mkcall1(chanfn(fnname, 1, n.Type), n.Type, init, typename(n.Type), conv(size, argtype))
    }
}

发送数据

向 channel 发送数据的语句会在编译期间转换成 chansend 函数

ch := make(chan int)
ch <- 10

发送语句非常简单，但是真正的函数执行会区分很多的情况，做一些小的优化，可以称为特性

发送操作的特性

• 向 nil channel 发送数据会被永久阻塞，并且不会被 select 语句选中
• 如果 channel 未关闭，非缓冲并且没有待接收的 goroutine，或者缓冲区已满，那么不会被 select 语句选中
• 向关闭的 channel 发送数据，会 panic ，并且可以被 select 语句选中，意味着 select 语句中可能会 panic
• 如果有待接收者，那么会将发送的数据直接 copy 到待接收者的接收位置，然后唤醒接收者
• 如果有缓冲区，并且缓冲区未满，那么就把发送的数据 copy 到缓冲区中
• 如果 channel 未关闭，缓冲区为空并且没有待接收者，那么直接阻塞当前 goroutine, 等待被唤醒
• 发送者被阻塞后，可以被关闭 channel 操作或者被接收操作唤醒，关闭 channel 导致发送者被唤醒后，会panic
• 当 channel 中有待接收 goroutine，那么 channel 的状态必然是 非缓冲或者缓冲区为空

发送数据，可以被 select 选中的情况

• channel 已关闭
• channel 未关闭，channel有待接收的 goroutine，或者缓冲区不为空并且缓冲区未满

深入源码

ch <- i 发送语句实际会被转换为 chansend1

func chansend1(c *hchan, elem unsafe.Pointer) {
    chansend(c, elem, true, getcallerpc())
}

chansend1 会直接调用 chansend 来发送数据，并且 block 为 true，说明 ch <- i 语句可以被阻塞

// src/runtime/chan.go

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool 

c 表示操作的 channel
ep 是一个指针，指向发送的数据 ch <- i
block 表示是否是阻塞调用，在 select case 语句中才会设置为 false
callerpc 暂时不需要关心

返回值是个 bool 类型，表示是否发送成功，未发送成功的操作也不会被 select 语句选中

首先看一下 channel 为 nil 的情况，这时并不需要加锁

    if c == nil{
        if !block {
            // block 为 false, 则直接返回 false, 表示发送失败
            return false
        }
        // 对于 nil channel，直接挂起当前 goroutine，并永久阻塞
        gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
        // 不会执行到这一步
        throw("unreadable")
    }

如果是非阻塞调用，也就是 select case 语句中调用，那么直接返回 false，意味着向 nil channel 发送数据不会被选中
阻塞调用就被 gopark 挂起，永久阻塞

在 channel 加锁之前，对于非阻塞并且未关闭的情况会有一步快速检测的判断，可以快速返回

    // 快速检测，非阻塞时，有些情况不需要获取锁就可以直接返回
    // 非阻塞，未关闭，非缓冲+没有等待接收的 goroutine 或者 缓冲+缓冲区已满
    if !block && c.closed == 0 &&
        ((c.dataqsiz == 0 && c.recvq.first == nil) ||
        ((c.dataqsiz < 0 && c.qcount == c.dataqsiz)) {
        // 返回 false，表示未发送成功
        return false
    }

缓冲区没有空间，并且待接收的 goroutine 时，可以直接返回未发送成功

加锁，判断 channel 是否关闭，如果已关闭，直接 panic

// 加锁
    lock(&c.lock)
    
    // 如果 channel 已关闭，则 panic
    if c.closed != 0{
        unlock(&c.lock)
        panic(plainError("send on closed channel"))
    }

channel 待接收队列中有等待的 goroutine

    lock(&c.lock)
    
    // ...
    
    // 从待接收队列中获取等待的 goroutine
    if sg := c.recvq.dequeue(); seq != nil {

        // 只要可以从待接收队列中获取到 goroutine，那么发送操作都是只需要 copy 一次
        send(c, sg, ep, func() { unlock(&c.lock) },  3)
        return true
    }

如果待接收队列中有等待的接收者的话，说明 channel 的缓冲区为空
调用 send 函数，无论是否是无缓冲 channel，都直接复制给待接收者

func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // sg.elem 是指向待接收 goroutine 中接收数据的指针 s <- ch
    // 如果待接收 goroutine 需要接收具体的数据，那么直接将数据 copy 到 sg.elem
    if sg.elem != nil{
        sendDirect(c.elemtype, sg, ep)
        sg.elem = nil
    }
    
    gp := sg.g
    unlockf()   // unlock(&c.lock)
    
    // 赋值 param，待接收者被唤醒后会根据 param 来判断是否是被发送者唤醒的
    gp.param = unsafe.Pointer(sg)
    goready(gp, skip+1) // 唤醒待接收者
}

会判断一下接收者是否需要接收数据，也就是 sudog.elem 是否为 nil
如果不为 nil，就调用 sendDirect 把发送的数据（ep 指向的数据） 复制到 sudog.elem

func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
    // src 是发送的数据源地址，dst 是接收数据的地址
    // src 在当前的 goroutine 栈中，而 dst 在其他栈上
    dst := sg.elem
    
    // 使用 memove 直接进行内存 copy
    // 因为 dst 指向其他 goroutine 的栈，如果它发生了栈收缩，那么就没有修改真正的 dst 位置
    // 所以会加读写前加一个屏障
    typebitsBulkBarrier(t, uintptr(dst), uintptr(src), t.size)
    memove(dst, src, t.size)    

sendDirect 在进行跨 goroutine 内存 copy 时，调用 typebitsBulkBarrier 来加上了写屏障
因为 GC 会假设对栈的写操作只会发生在 goroutine 正在运行时，并且是由当前 goroutine 写的，
而 sendDirect 跨 goroutine 的栈读写会违背这个假设，为了避免出现问题，需要加上写屏障

缓冲区未满，直接将数据发送到缓冲区中

    lock(&c.lock)
    // ...
    
    if c.qcount < c.dataqsiz {
        //  获取缓冲发送数据的指针
        // add(c.buf, uintptr(i)*uintptr(c.elemsize))
        qp := chanbuf(c, c.sendx)
        
        // copy 数据，ep, gp 都是指针，分别指向数据源和数据目的地
        typedmemove(c.elemtype, qp, ep)
        
        // 递增存放发送数据的索引
        c.sendx++
        if c.sendx == c.dataqsiz{
            // 缓冲区是一个循环数组，调整索引
            c.sendx = 0
        }
        c.qcount++
        unlock(&c.lock)
        return true
    }

chanbuf 函数通过 hchan.sendx 获取到缓冲区存放发送的数据的地址，然后调整循环数组的sendx 索引

channel 未关闭，对于非缓冲 channel，待接收队列为空，对于缓冲 channel，缓冲区已满
逻辑依次执行到这里：

    lock(&c.lock)
    // ...
    
    // 如果非阻塞发送，那么可以直接解锁返回，未发送成功
    if !block{
        unlock(&c.lock)
        return false
    }
    
    // 阻塞发送，那么就挂起当前 goroutine
    gp := getg()
    // 生成配置 sudo，省略部分赋值操作
    mysg := acquireSudog()
    mysg.elem = ep  // 将指向发送数据的指针保存到 elem 中
    mysg.g = gp
    mysg.c = c  // 当前阻塞的 channel
    gp.wait = mysg
    
    // param 可以用来传递数据，其他 goroutine 唤醒该 goroutine 时可以设置该字段，然后根据该字段做一些判断
    pg.param = nil  
    
    // 入队待发送队列
    c.sendq.enqueue(mysg)

    // 挂起goroutine，等待唤醒
    // chanparkcommit 函数会解锁 ch.lock
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)

非阻塞的话，会直接返回为发送成功
阻塞调用，则会构建 sudog 对象，然后添加到待发送队列，解锁，挂起当前 goroutine

会被唤醒的情况有两种

• 关闭 channel
• 发生接收操作，接收者可能会唤醒该发送者

    // 被唤醒，执行检查清理操作
    // ...
    
    // param 字段为 nil 表示是由于 close channel 导致的关闭，panic
    // close channel 和接收操作都可能唤醒等待发送的 goroutine, 但是他们设置 param 不一样
    if gp.param == nil {
        if c.closed = 0 {
            throw("chansend: suprious wakeup")
        }
        panic(plainError("send on closed channel"))
    }
    // 清理，释放 sudog
    pg.param == nil
    mysq.c = nil
    releaseSudog(mysg)
    // 发送成功
    return true
}

被唤醒后会判断 g.param 是否为 nil，因为关闭 channel 时会将待发送 goroutine 的 param 字段置为 nil，会根据这个字段决定是否 panic

select & 发送操作

golang 会对 select 语句进行一些优化

单个发送 case

select {
case ch <- i:
    // ...
}

// 会被优化为

if ch == nil {
    block()
}
ch <- i

会在编译期间转换为阻塞发送语句

非阻塞操作，发送 + default

select {
case ch <- i:
    // ...
default:
    // ...
}

// =====>

if selectnbsend(ch, i) {
    // ...
} else {
    // ...
}

非阻塞操作实际调用 selectnbsend，根据函数返回值决定是否执行 default 逻辑

func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
    // block 参数为 false，非阻塞调用
    return chansend(c，elem, false, getcallerpc())
}

返回 false 表示未发送成功，select 便会执行 default

思考：为什么向关闭的 channel 发送数据需要 panic

接收数据

如何从 channel 中接收数据

// 接收单个值，如果 channel 被关闭后，会返回 channel 中元素的零值
i <- ch // 调用 `chanrecv1` 函数

// 如果 channel 被关闭并且缓冲区为空，那么 ok 的值就是 false
i, ok <- ch // 调用 `chanrecv2` 函数

i 是接收操作的接收值，ok 表示是否从 channel 中接收到有效的数据，即使 channel 已经关闭，但是缓冲区中依然存在数据，那么 ok 也会是 true

接收操作的特性

• 从 nil channel 中接收数据会永久阻塞，而且不会被select 语句选中
• 如果 channel 未关闭，没有待发送者或者缓冲 channel 的缓冲区为空的话，不会被 select 语句选中
• 从已关闭并且缓冲区为空的 channel 中接收数据的话，会把接收值置为空值，而且可以被 select 语句选中
• 如果待发送队列不为空，说明无缓冲或者缓冲已满，对于无缓冲直接从待发送者复制数据到接收值，如果缓冲区已满，那么先将缓冲区中数据复制给接收者，然后将待发送者的数据复制到缓冲区中并唤醒发送者
• 只要缓冲区不为空，即使channel已关闭，依然可以从缓冲区中获取到数据
• 如果缓冲为空并且没有待发送者，不会被 select 语句选中，如果是阻塞接收操作的话，会被阻塞直到 channel 被关闭或者被发送者唤醒
• 接收者被关闭操作唤醒，那么接收值会被置为空值

接收操作被 select 语句选中的情况

• channel 已关闭
• 缓冲区中有数据
• 待发送队列不为空

深入源码

单值的接收语句实际调用 chanrecv1

// src/runtime/chan.go
i <- ch

// ===>

func chanrecv1(c *hchan, elem unsafe.Pointer){
    chanrecv(c, elem, true)
}

接收两个值实际调用 chanrecv2

i, ok <- ch

// ===>

func chanrecv2(c *hchan, elem unsafe.Pointer)(received bool) {
    _, received = chanrecv(c, elem, true)
}

chanrecv1 和 chanrecv2 实际都是调用 chanrecv ，他们两个之间的区别就是是否返回接收到有效数据

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool)

c 表示接收操作的 channel
ep 是一个指针，指向接收值，i <- ch语句 ep 就是 接收值 i 的地址
block 是否是阻塞操作，chanrecv1 和 chanrecv2 函数中block为 true，说明是阻塞操作

返回值 selected 表示是否可以被 select 语句选中
返回值 received 表示是否可以接收到有效数据

**channel 在加锁前会判断一下是否为 nil **

    if c == nil {
        // 非阻塞下会直接返回
        if !block {
            return
        }
        // 永久挂起
        gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
        throw("unreachable")
    }

阻塞接收会被永久阻塞，非阻塞的话就直接返回，而且不会被 select 选中

阻塞接收时，对于未关闭 channel 满足一些条件不需要加锁就可以直接返回

    // 快速检测，在非阻塞模式下，和发送一样有些条件不需要加锁就可以直接判断返回
    // 非阻塞并且未关闭，非缓冲+没有待发送者或者有缓冲+缓冲为空
    if !block && (c.dataqsiz == 0 && c.sendq.first == nil ||
        c.dataqsiz > 0 && atomic.Loaduint(&c.qcount) == 0) &&
        atomic.Load(&c.closed) == 0 {
        return
    }

• 非缓冲 channel 如果没有待发送者
• 缓冲 channel 但是缓冲区为空

加锁，首先判断 channel 是否已关闭，缓冲区中是否还有数据

    lock(&c.lock)
    
    // channel 处于关闭，并且缓冲区已空
    if c.closed != 0 && c.qcount == 0{
        unlock(&c.lock)
        if ep != nil{
            // 如果接收的值需要赋值到变量 x <- ch
            // 将接收的值置为空值
            typedmemclr(c.elemtype, ep)
        }
        // 可被 select 语句选中，但是未接收到有效数据
        return true, false
    }

channel 已经关闭，而且缓冲区没有数据，如果 ep 不为nil ，也就是说存在接收值，那么就把接收值置为空值

ep 为空的情况是 <- chan 接收操作没有接收值

selected 返回 true，表示可以被 select 语句选中

待发送队列不为空，存在待发送者

    lock(&c.lock)
    // ...
    
    // 待发送队列中有 goroutine，说明是非缓冲 channel 或者 缓冲已满的 channel
    if sg := c.sendq.dequeue(); sg != nil {
        recv(c, sg, ep, func(){ unlock(&c.lock) }, 3)
        return true, true   // 可被选中，并且接收成功
    }

如果待发送队列中有等待发送的 goroutine，说明 channel 是非缓冲channel，或者缓冲区已经满了

• 非缓冲channel，会将数据从待发送者复制给接收者
• 缓冲区已满的话，会先从缓冲区中接收数据，然后将待发送者的数据发送到缓冲区中

这里和发送操作时，channel 的待接收队列不为空的情况不一样，因为待接收队列不为空，说明缓冲区肯定是没有数据的，可以跳过缓冲区，直接将数据发送到等待接收的 goroutine

因为要区分 channel 的类型所以 recv 函数的逻辑就会有一点复杂
对于非缓冲 channel，如果有接收值，直接调用 recvDirect 从待发送者复制值

func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // 无缓冲 channel
    if c.dataqsiz == 0 {
        // 如果ep 不为 nil，那么直接从发送 goroutine 中将数据 copy 到接收位置
        if ep != nil{
            recvDirect(c.elemtype, sg, ep)
        }
    } 

对于缓冲区有数据的情况

• 先从缓冲区复制数据到接收值，也就是 ep 指向的地址
• 然后将待发送者要发送的数据复制到缓冲区中
• 调整缓冲区循环数据的接收索引 recvx

    } else {
        // 获取缓冲区中待接收的地址
        gp := chanbuf(c, c.recvx)
        if ep != nil {
            // 将待接收数据复制到接收位置
            typedmemmove(c.elemtype, ep, qp)
        }
        // 将待发送者发送的数据复制到相应缓冲区的位置
        typedmemmove(c.elemtype, qp，sq.elem)
        // 调整 recvx
        c.recvx++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        // 由于缓冲区已满，sendx 和 recvx 必然相等
        c.sendx = c.recvx
    }

无论是缓冲还是非缓冲 channel，recv 函数最后都会唤醒发送者

    // 赋值发送者的 param，发送者被唤醒后会根据 param 来判断是否是关闭唤醒的
    sg.elem = nil
    gp := sg,g
    unlockf()
    gp.param = unsafe.Pointer(sg)
    goready(gp, skip+1)
}

接收操作会赋值发送者 goroutine 的 param 字段，发送者被唤醒后，会根据 param 参数来判断是有接收操作唤醒还是被关闭 channel 操作唤醒

缓冲区中有数据，无论 channel 被关闭，都会发送给接收者

    lock(&c.lock)
    // ...
    
    // 如果缓冲区不为空，依然有未发送的数据
    // 需要注意，这时 channel 可能已经处于关闭状态了，但是依然可以从关闭的缓冲区中接收到数据
    if c.qcount > 0{
        // 获取指向缓冲区中待接收数据的指针
        gp ;= chanbuf(c, c.recvx)
        if ep != nil{
            // 如果接收操作有接收值，那么直接 copy 到 ep
            typedmemmove(c.elemtype, ep, gp)
        }
        // 清理缓冲区中已接收到的数据内存
        typedememclr(c.elemtype, gp)
        // 调整待接收索引
        c.recv++
        if c.recvx == c.dataqsiz {
            c.recvx = 0
        }
        c.qcount--
        unlock(&c.lock)
        // 可以被选中，并且接收成功
        return true, true
    }

这一部分的逻辑就比较简单

• 获取缓冲区的待接收数据的地址 gp，如果有接收者，便将数据复制给接收者
• 调整缓冲区循环数据的待接收索引recvx

channel 未关闭， 缓冲区没有元素，并且没有待接收者
非阻塞操作，可以直接解锁返回，并且不会被 select 语句选中

    lock(&c.lock)
    // ...

    // 缓冲区没有元素并且没有待发送者
    if !block {
        unblock(&c.block)
        // 不会被选中，并且没有接收到有效数据
        return false, false
    }

阻塞操作，挂起当前 goroutine，等待被发送操作或者关闭操作唤醒

    lock(&c.lock)
    // ...

    gp = getg()
    mysg := acquireSudog()
    mysg.elem = ep
    mysg.g = gp
    mysg.c = c
    gp.param = nil

    // 入队到待发送者队列中
    c.recvq.enqueue(mysg)
    // 挂起 goroutine，等待由关闭操作或者发送操作唤醒
    goparkunlock(&c.lock, waitReasonChanReceive, traceEvGoBlockRecv, 3)
    
    // 被唤醒，做一些检测，和清理操作
    
    // 根据 param 判断是否是由关闭唤醒的
    // 有 closed 唤醒时，param 会被置为 nil
    closed := gp.param == nil   
    pg.param = nil
    mysg.c = nil
    releaseSudog(mysg)
    
    // 可以被选中，但是 closed 反应是否接受到有效数据
    return true, !closed
}

被唤醒后会根据 param 字段，判断是否是由关闭操作唤醒

select 与 接收操作

单个接收 case

select {
case i <- ch:
}
// ====>

if ch == nil{
    block()
}
i <- ch

非阻塞接收

select {
case v <- ch: // case v, received <- ch:
    // ...
default:
    // ...
}
// ===>

// if ch != nil && selectnbrecv2(&v, &ok, ch) {
if selectnbrecv(&v, ch) { 
    // ...
} else {
    // ...
}

非阻塞接收会调用 selectnbrecv 和 selectnbrecv2

func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected bool) {
    selected, _ = chanrecv(c, elem, false)
    return
}
func selectnbrecv2(elem unsafe.Pointer, received *bool, c *hchan) (selected bool) {
    elected, *received = chanrecv(c, elem, false)
    return
}

关闭 channel

关闭 channel 直接调用 close 函数即可，但是贸然关闭 channel 会引发很多的问题

ch := make(chan int)

// 关闭 goroutine
close(ch)

关闭操作的特性

• 关闭 nil channel 会 panic
• 关闭已关闭的 channel 会 panic
• 关闭操作会将待接收者的接收值置为空值，唤醒所有待发送者和待接收者

关于如何优雅的关闭 channel，可以看一下 go101 中 如何优雅地关闭通道

深入源码

关闭 nil channel 会panic

func closechan(c *hchan) {
    // 关闭 nil channel 会 panic
    if c == nil{
        panic(plainError("close of nil channel"))
    }

重复关闭 channel，也会 panic

    // 加锁
    lock(&c.lock)
    if c.closed != 0 {
        // 重复关闭会 panic
        unlock(&c.lock)
        panic(plainError("close of closed channel"))
    }

需要注意关闭操作中，判断 channel 是否关闭前会加锁

处理待接收者，如果有接收者，那么就置为空值

    c.closed = 1

    var glist gList
    // 处理待接收者
    for {
        sg := c.recvq.dequeue()
        if sg == nil {
            break
        }
        if sg.elem != nil {
            // 将待接收位置置为空值
            typedmemclr(c.elemtype, sg.elem)
            sg.elem = nil   //  清理 elem 指针
        }
        gp := sg.g
        // param 置为 nil，接收者被唤醒后会返回未接收到有效数据
        gp.param = nil
        glist.push(gp)
    }

处理待发送者

    // 处理待发送的队列
    for {
        sg := c.sendq.dequeue()
        if sg == nil {
            // 没有待发送的goroutine了
            break
        }
        sg.elem = nil
        gp := sg.g
        // 将 param 置为 nil, 待发送者被唤醒后，会 panic
        gp.param = nil
        glist.push(gp)
    }

解锁，唤醒所有待发送者和待接收者

    unlock(&c.lock)
    
    // 唤醒所有阻塞的 goroutine
    for !glist.empty(){
        gp := glist.pop()
        gpready(gp, 3)
    }
}

关闭操作唤醒 channel 中阻塞的 goroutine

在处理待发送者和待接收者时，都会将 goroutine 的 param 字段置为 nil，然后当被唤醒后待发送者和待接收者就能区分如何被唤醒的

发送操作

// runtime/chan.go

func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
    // ...

    // 阻塞，挂起 goroutine
    gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)

    if gp.param == nil {
        if c.closed = 0 {
            throw("chansend: suprious wakeup")
        }
        panic(plainError("send on closed channel"))
    }
    // ...

可以看到发送操作被唤醒后会判断 param 字段
如果是由于 channel 关闭导致被唤醒，那么直接 panic

• 关闭操作唤醒，goroutine param 字段为 nil

func closechan(c *hchan) {
    // ...
    for {
        sg := c.recvq.dequeue()
        // ...
        pg := sg.pg
        gp.param = nil
        // ...
    }
    // ... 唤醒 goroutine
}

• 接收操作唤醒，goroutine param 不为 nil

func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
    // ... 数据复制
    
    pg := sg.g
    pg.param = unsafe.Pointer(sg)
    goready(gp, skip+1)
}
    

接收操作

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // ...
    
    // 阻塞，挂起当前 goroutine
    goparkunlock(&c.lock, waitReasonChanReceive, traceEvGoBlockRecv, 3)
    // 被唤醒
    // ...
    
    closed := gp.parma == nil
    // ...
    return true, !closed

接收操作在关闭后并不会 panic，而是会作为 received 返回，表示是否接收到有效的数据

参考资料

深度解密Go语言之channel
Go 语言设计与实现 —— Channel

推荐阅读

Go101 通道
如何优雅地关闭通道
浅谈 Go 语言 select 的实现原理
图解Go的channel底层原理
走进Golang之Channel的使用
走进Golang之Channel的数据结构