go chan 设计与实现

在上一篇文章《深入理解 go chan》中，我们讲解了 chan 相关的一些概念、原理等东西，
今天让我们再深入一下，读一下它的源码，看看底层实际上是怎么实现的。

整体设计

我们可以从以下三个角度看 chan 的设计（源码位于 runtime/chan.go，结构体 hchan 就是 chan 的底层数据结构）：

• 存储：chan 里面的数据是通过一个环形队列来存储的（实际上是一个数组，但是我们视作环形队列来操作。无缓冲 chan 不用存储，会直接从 sender 复制到 receiver）
• 发送：数据发送到 chan 的时候，如果 chan 满了，则会将发送数据的协程挂起，将其放入一个协程队列中，chan 空闲的时候会唤醒这个协程队列。如果 chan 没满，则发送队列为空。
• 接收：从 chan 中接收数据的时候，如果 chan 是空的，则会将接收数据的协程挂起，将其放入一个协程队列中，当 chan 有数据的时候会唤醒这个协程队列。如果 chan 有数据，则接收队列为空。

文中一些比较关键的名词解释：

• sender: 表示尝试写入 chan 的 goroutine。
• receiver: 表示尝试从 chan 读取数据的 goroutine。
• sendq 是一个队列，存储那些尝试写入 channel 但被阻塞的 goroutine。
• recvq 是一个队列，存储那些尝试读取 channel 但被阻塞的 goroutine。
• g 表示一个协程。
• gopark 是将协程挂起的函数，协程状态：_Grunning => _Gwaiting。
• goready 是将协程改为可运行状态的函数，协程状态: _Gwaiting => _Grunnable。

现在，假设我们有下面这样的一段代码，通过这段代码，我们可以大概看一下 chan 的总体设计：

package main

func main() {
   
	// 创建一个缓冲区大小为 9 的 chan
	ch := make(chan int, 9)
	// 往 chan 写入 [1,2,3,4,5,6,7]
	for i := 0; i < 7; i++ {
   
		ch <- i + 1
	}
	// 将 1 从缓冲区移出来
	<-ch
}

现在，我们的 chan 大概长得像下面这个样子，后面会详细展开将这个图中的所有元素：

上图为了说明而在 recvq 和 sendq 都画了 3 个 G，但实际上 recvq 和 sendq 至少有一个为空。因为不可能有协程正在等待接收数据的时候，还有协程的数据因为发不出去数据而阻塞。

数据结构

在底层，go 是使用 hchan 这个结构体来表示 chan 的，下面是结构体的定义：

type hchan struct {
   
	qcount   uint           // 缓冲区（环形队列）元素个数
	dataqsiz uint           // 缓冲区的大小（最多可容纳的元素个数）
	buf      unsafe.Pointer // 指向缓冲区入口的指针（从 buf 开始 qcount * elemsize 大小的内存就是缓冲区所用的内存）
	elemsize uint16 // chan 对应类型元素的大小（主要用以计算第 i 个元素的内存地址）
	closed   uint32 // chan 是否已经关闭（0-未关闭，1-已关闭）
	elemtype *_type // chan 的元素类型
	sendx    uint   // chan 发送操作处理到的位置
	recvx    uint   // chan 接收操作处理到的位置
	recvq    waitq  // 等待接收数据的协程队列（双向链表）
	sendq    waitq  // 等待发送数据的协程队列（双向链表）

	// 锁
	lock mutex
}

waitq 的数据结构如下：

type waitq struct {
   
	first *sudog
	last  *sudog
}

waitq 用来保存阻塞在等待或接收数据的协程列表（是一个双向链表），在解除阻塞的时候，需要唤醒这两个队列中的数据。

对应上图各字段详细说明

hchan，对于 hchan 这个结构体，我们知道，在 go 里面，结构体字段是存储在一段连续的内存上的（可以看看《深入理解 go unsafe》），所以图中用了连续的一段单元格表示。

下面是各字段说明：

• qcount: 写入 chan 缓冲区元素个数。我们的代码往 chan 中存入了 7 个数，然后从中取出了一个数，最终还剩 6 个，因此 qcount 是 6。
• dataqsiz: hchan 缓冲区的长度。它在内存中是连续的一段内存，是一个数组，是通过 make 创建的时候传入的，是 9。
• buf：hchan 缓冲区指针。指向了一个数组，这个数组就是用来保存发送到 chan 的数据的。
• sendx、recvx：写、读操作的下标。指向了 buf 指向的数组中的下标，sendx 是下一个发送操作保存的下标，recvx 是下一个接收操作的下标。
• recvq、sendq: 阻塞在 chan 读写上的协程列表。底层是双向链表，链表的元素是 sudog（sudog 是一个对 g 的封装），我们可以简单地理解为 recvq 和 sendq 的元素就是 g（协程）。

g 和 sudog 是什么？

上面提到了 g 和 sudog，g 是底层用来表示协程的结构体，而 sudog 是对 g 的封装，记录了一些额外的信息，比如关联的 hchan。

在 go 里面，协程调度的模型是 GMP 模型，G 代表协程、M 代表线程、P 表示协程调度器。我上图里面的 G 就是代表协程（当然，实际上是 sudog）。
还有一个下面会提到的就是 g0，g0 表示 P 上启动的第一个协程。

GMP 模型是另外一个庞大的话题了，大家可以自行去了解一下，对理解本文也很有好处。因为在 chan 阻塞的时候实际上也是一个协程调度的过程。
具体来说，就是从 g 的栈切换到 g0 的栈，然后重新进行协程调度。这个时候 g 因为从运行状态修改为了等待状态，所以在协程调度中不会将它调度来执行，
而是会去找其他可执行的协程来执行。

创建 chan

我们的 make(chan int, 9) 最终会调用 makechan 方法：

// chantype 是 chan 元素类型，size 是缓冲区大小
func makechan(t *chantype, size int) *hchan {
   
	elem := t.elem

	// compiler checks this but be safe.
	// 检查元素个数是否合法（不能超过 1<<16 个）
	if elem.size >= 1<<16 {
   
		throw("makechan: invalid channel element type")
	}
	// 判断内存是否对齐
	if hchanSize%maxAlign != 0 || elem.align > maxAlign {
   
		throw("makechan: bad alignment")
	}

	// mem 是 chan 缓冲区（环形队列）所需要的内存大小
	// mem = 元素大小 * 元素个数
	mem, overflow := math.MulUintptr(elem.size, uintptr(size))
	if overflow || mem > maxAlloc-hchanSize || size < 0 {
   
		panic(plainError("makechan: size out of range"))
	}

	// 定义 hchan
	var c *hchan
	switch {
   
	case mem == 0:
		// 队列或者元素大小是 0（比如 make(chan int, 0)）
		// 只需要分配 hchan 所需要的内存
		c = (*hchan)(mallocgc(hchanSize, nil, true))
		// ... 
	case elem.ptrdata == 0:
		// elem 类型里面不包含指针
		// 分配的内存 = hchan 所需内存 + 缓冲区内存
		c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
		// 分配的是连续的一段内存，缓冲区内存在 hchan 后面
		c.buf = add(unsafe.Pointer(c), hchanSize)
	default:
		// 元素类型里面包含指针
		c = new(hchan)
		// buf 需要另外分配内存
		c.buf = mallocgc(mem, elem, true)
	}

	// 单个元素的大小
	c.elemsize = uint16(elem.size)
	// 元素类型
	c.elemtype = elem
	// 缓冲区大小
	c.dataqsiz = uint(size)
	// ...
}

创建 chan 的过程主要就是给 hchan 分配内存的过程：

• 非缓冲 chan，只需要分配 hchan 结构体所需要的内存，无需分配环形队列内存（数据会直接从 sender 复制到 receiver）
• 缓冲 chan（不包含指针），分配 hchan 所需要的内存和环形队列所需要的内存，其中 buf 会紧挨着 hchan
• 缓冲 chan（含指针），hchan 和环形队列所需要的内存单独进行分配

对应到文章开头的图就是，底下的 hchan 和 buf 那两段内存。

发送数据

<- 语法糖

在《深入理解 go chan》中，我们说也过，<- 这个操作符号是一种语法糖，
实际上，<- 会被编译成一个函数调用，对于发送操作而言，c <- x 会编译为对下面的函数的调用：

// elem 是被发送到 chan 的数据的指针。
// 对于 ch <- x，ch 对应参数中的 c，unsafe.Pointer(&x) 对应参数中的 elem。
func chansend1(c *hchan, elem unsafe.Pointer) {
   
    chansend(c, elem, true, getcallerpc())
}

另外，对于 select 里面的调用，chansend 会返回一个布尔值给 select 用来判断是否是要选中当前 case 分支。
如果 chan 发送成功，则返回 true，则 select 的那个分支得以执行。（select...case 本质上是 if...else，返回 false 表示判断失败。）

chansend 第二个参数的含义

chansend 第二个参数 true 表示是一个阻塞