---

title: Golang语言笔记: 理解 Channel 特性
date: 2018-04-20 20:00:00
tags: Golang

---

---

理解 channel 特性

本文是对 Gopher 2017 中一个非常好的 Talk�: [Understanding Channel](GopherCon 2017: Kavya Joshi - Understanding Channels) 的学习笔记，希望能够通过对 channel 的关键特性的理解，进一步掌握其用法细节以及 Golang 语言设计哲学的管窥蠡测。

文章内容包括:
[TOC]

channel

channel 是可以让一个 goroutine 发送特定值到另一个 gouroutine 的通信机制。

• 可以理解为某种类型的值传递的导管，而这种在 channel 中传递的类型成为 channle 的 element type 元素类型。
• 一个使用make创建的，对数据结构的引用，当把 channel 作为参数使用时，实际上是传引用调用
• channel 的零值: nil

如何使用 channel？

原生的 channel 是没有缓存的(unbuffered channel)，可以用于 goroutine 之间实现同步。

• 发送 sends 和接收 receives

ch := make(chan int) // ch hase type `chan int`

ch <- x // a send statement
x = <-ch // a receive expression in an assignment statement
<-ch // a receive statement; result is discarded

• 关闭 close

close(ch)

关闭后不能再写入，可以读取直到 channel 中再没有数据，并返回元素类型的零值。

• buffered channel的创建

ch := make(chan int) // unbuffered channel
ch := make(chan int, 0) // unbuffered channel
ch := make(chan int, 3) // buffered channel with capacity 3

buffered channel 可以用于非常方便的实现生产者-消费者模型，实现异步操作。

使用 unbuffered channel 实现同步

gopl/ch3/netcat3

func main() {
    conn, err := net.Dial("tcp", "localhost:8008")
    if err != nil {
        log.Fatal(err)
    }
    // communication over an buffered channel causes the sending and
    // receiving goroutines to synchronize
    done := make(chan struct{})
    go func() {
        io.Copy(os.Stdout, conn) // NOTE; ignoring errors
        log.Println("Done")
        done <- struct{}{} // signal the main goroutine
    }()
    mustCopy(conn, os.Stdin)
    conn.Close()
    <-done
}

channel 的特性

• goroutine-safe
  goroutine 安全
• store and pass values between goroutines
  存储数据并在 goroutine 之间传递数据
• provide FIFO semantics
  提供 FIFO 语义
• can cause goroutines to block and unblock
  可以使得 goroutine 阻塞或者释放

这些特性是怎么做到的？

making channels

首先从 channel 是怎么被创建的开始:

一个 channel 的诞生

在heap上分配一个hchan类型的对象，并将其初始化，然后返回一个指向这个hchan对象的指针。

• heap上而不是stack上
• hchan类型
• 返回的是指针

sends and receives

理解了 channel 的数据结构实现，现在转到 channel 的两个最基本方法: sends 和 receivces ，看一下以上的特性是如何体现在 sends 和 receives 中的:

goroutine-safe 的实现

假设发送方先启动，执行ch <- task0:

1. 获取lock，加锁;
2. 对Task类型的对象task0执行入队操作;
3. 完成入队操作后，释放锁

需要特别指出的是，这里的入队enqueue操作实际上是一次memcopy行为，将整个task0复制一份到buf，也就是FIFO缓冲队列中。

如此为 channel 带来了 goroutine-safe的特性。

在这样的模型里，sender goroutine -> channel -> receiver goroutine 之间，hchan是唯一的共享内存，而这个唯一的共享内存又通过mutex来确保goroutine-safe，所有在队列中的内容都只是副本。
这便是著名的 golang 并发原则的体现:

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

控制 goroutine 之间同步的实现

• 当 channel 中的缓存满了，发送方继续发送，会发生什么？

发送方 goroutine 会阻塞，暂停，并在收到receive后才恢复。

• 这是怎么做到的？

goroutine 是一种用户态线程, 由 Go runtime 创建并管理，而不是操作系统，比起操作系统线程来说，goroutine更加轻量。
Go runtime scheduler 负责将 goroutine 调度到操作系统线程上。

runtime scheduler 怎么将 goroutine 调度到操作系统线程上？

当阻塞发生时，一次 goroutine 上下文切换的全过程:

1. 当发送方 goroutine 向已经满了的 channel 发送数据后，发生了 goroutine 的阻塞，goroutine 会对 runtime scheduler 发起一次gopark调用;
2. 当 sheduler 接收到gopark调用，会将现在正在运行的 goroutine G1从running置为waiting;
3. 并将G1和承载它的操作系统线程M之间的联系解除;
4. 从 runqueue 调度一个新的runnable goroutine G，并将其和M绑定，开始执行G

只是阻塞了 goroutine，没有阻塞操作系统线程。

然而，被阻塞的 goroutine 怎么恢复过来？

阻塞发生时，调用 runtime sheduler 执行gopark之前，G1 会创建一个sudog，并将它存放在hchan的sendq中。sudog中便记录了即将被阻塞的 goroutine G1，以及它要发送的数据元素task4等等。
接收方将通过这个sudog来恢复 G1

接收方 G2 接收数据, 并发出一个receivce，将 G1 置为 runnable:

1. G2 将队列中的第一个元素 task1 出队(接收 task1);
2. 将sendq中的sudog出栈，获取到G1和task4，然后将task4入队。在这里让 G2 而非 G1 执行元素入队操作的用意在于，这样 G1 恢复运行后无需再获取一次锁，将元素入队，然后再释放一次锁，即可以减少一次获取释放锁的过程;
3. 接下来 G2 要将 G1 置为 runnable。G2 向 runtime scheduler 发起一次goready调用，scheduler 将 G1 置为runnable，并将其入队到 runqueue，然后返回 G2。

• 当 channel 中的缓存空了，接收方继续接受，会发生什么？

同样的, 接收方 G2 会被阻塞，G2 会创建sudoq，存放在recvq，基本过程和发送方阻塞一样。
不同的是，发送方 G1如何恢复接收方 G2，这是一个非常神奇的实现。

理论上可以将 task 入队，然后恢复 G2, 但恢复 G2后，G2会做什么呢？
G2会将队列中的 task 复制出来，放到自己的 memory 中，基于这个思路，G1在这个时候，直接将 task 写到 G2的 stack memory 中！

这是违反常规的操作，理论上 goroutine 之间的 stack 是相互独立的，只有在运行时可以执行这样的操作。
这么做纯粹是出于性能优化的考虑，原来的步骤是：

1. G1 获取锁，将 task 进行入队(memcopy)
2. 当 G2 恢复时，获取锁并且读取 task(memcoy)

优化后，相当于减少了 G2 获取锁并且执行 memcopy 的性能消耗。

总结: 特性的实现

• goroutine-safe:
  • 通过 hchan mutex 实现
• store values, pass in FIFO:
  • 通过 hchan buffer实现
  • 通过共享 hchan buffer 进行传值（实际上是传递副本)
  • 唯一共享的 buffer 使用 hchan mutex 保证 goroutine 安全
• can cause goroutines to pause and resume
  • 通过 hchan sudog queues实现
  • 调用 runtime scheduler(gopark,goready)

simplicity 和 performance 的权衡

channel 设计背后的思想可以理解为 simplicity 和 performance 之间权衡抉择，具体如下：

Simplicity

queue with a lock prefered to lock-free implementation:

比起完全 lock-free 的实现，使用锁的队列实现更简单，容易实现

The performance improvement does not materiablize from the air, it comees with code complexity increase.
性能的提升(lock-free)不是凭空实现的，它来自代码复杂性的增长。

Performance