channel 的需求描述

為了理解這些數據結構解決了什么問題，我們先來做個簡單的回顧，看看為什么需要這兩個數據結構，他們解決了什么問題。我們知道 goroutine 是用戶態的線程，不同的 goroutine 之間是有消息傳遞這個需求的。在原始的進程與線程（系統線程）編程中我們會采用管道的方式，而 channel 就是用戶態線程傳遞消息的管道實現，并且是類型安全的。

既然 channel 是一個管道，用來滿足不同 goroutine 間交換消息的。那么實現這樣一個管道要怎么做呢？

來看看我們日常傳遞消息的需求：

1. 能夠有多個     goroutine 向     channel 進行讀寫，并且保證沒有競爭問題，需要用     隊列 來管理阻塞的     goroutine，解決競爭問題；
2. 需要管理發送到     channel 的消息（有緩沖、無緩沖），對于有緩存的     channel 可以采用     循環隊列 來管理多個消息。

當然上面的需求是經過簡化的，比如 channel 還需要具備阻塞、喚醒 goroutine 的能力，不過為了本文我們更加專注焦點問題，先只關注上面兩個問題。

channel 的數據結構

接下來我們分析一下 channel 在實際運行中，它的結構體是怎么樣的。當然這又分為兩種類型，有緩沖與無緩沖的。我們先來看一個無緩沖的情況。

無緩沖

先把示例代碼貼出來。就是兩個讀的 goroutine 被阻塞在一個無緩沖的 channel 上。

func main() {
 ch := make(chan int) // 無緩沖

 go goRoutineA(ch)
 go goRoutineB(ch)
 ch <- 1

 time.Sleep(time.Second * 1)
}

func goRoutineA(ch chan int) {
 v := <-ch
 fmt.Printf("A received data: %d\n", v)
}

func goRoutineB(ch chan int) {
 v := <-ch
 fmt.Printf("B received data: %d\n", v)
}

來看看當代碼執行到 ch <- 1 這一行之后 channel 的結構體被填充成什么樣子了！

注意其中 buf 字段可存儲的長度是0，這是因為 無緩沖 channel 不會用到循環隊列來存儲數據。它一定是等讀、寫 goroutine 都準備好了，然后直接把數據交給對方。我們用一副圖來看一下無緩沖的數據交換過程。

上圖描述的是數據交換過程，再看一下讀 goroutine 被阻塞的結構示意圖。被阻塞的 goroutine 會掛載到對應的隊列上，該隊列是一個雙端隊列。

上面的例子，由于兩個讀 goroutine 在啟動的時候，寫還沒有準備好，因此讀全部被掛起在隊列中；當有寫goroutine準備好的時候，由于此時讀已經就緒，因此寫不會阻塞，掛起放到 sendq 中。大家可以修改上面的代碼，自己看一下寫阻塞，讀立馬執行的情況。

有緩沖

我們將上面的代碼改成有緩沖的通道，然后再來看看有緩沖的情況。

func main() {
 ch := make(chan int, 3) // 有緩沖

 // 都不會阻塞
 ch <- 1
 ch <- 2
    ch <- 3
    // 會阻塞，被掛起到 sendq 中
 go func() {
  ch <- 4
 }()

 // 只是為了debug
 var a int
 fmt.Println(a)

 go goRoutineA(ch)
 go goRoutineA(ch)
 go goRoutineB(ch)
 go goRoutineB(ch) // 猜猜這里會被掛起嗎？

 time.Sleep(time.Second * 2)
}

func goRoutineA(ch chan int) {
 v := <-ch
 fmt.Printf("A received data: %d\n", v)
}

func goRoutineB(ch chan int) {
 v := <-ch
 fmt.Printf("B received data: %d\n", v)
}

貼出執行到第一行的 go goRoutineA(ch) 時， hchan 的結構填充情況。

在這里可以看到緩沖的大小是3，由于增加了緩沖，只要寫 goroutine 沒有把緩沖寫滿，則不會導致協程阻塞。但是一旦緩沖沒有多余的空間，則會把寫 goroutine 掛起到 sendq 中，直到有空間時將他喚醒（還有其它喚醒的場景，這一略過）。

其實有緩沖的 channel，就是把同步的通信變為了異步的通信。寫的 channel 不需要關注讀 channel，只要有空間它就寫；而讀也一樣，只要有數據就正常讀就可以，如果沒有就掛起到隊列中，等待被喚醒。下圖形象的展示了有緩沖 channel 是如何交換數據的。

我們再來用圖的形式看一下此時結構體的樣子，這里圖有些偷懶，只是在上面圖的基礎上增加了循環隊列部分的描述，實際到該例子中，讀 goroutine時不會被阻塞的，看的時候需要注意這一點。

循環隊列

今天最重要的是理解 channel 中兩個關鍵的數據結構。為了下一講閱讀源碼做準備，我把 channel 中的循環隊列部分的代碼抽象出來了。

// 隊列滿了
var ErrQFull = errors.New("circular is full")

// 沒有值
var ErrQEmpty = errors.New("circular is empty")

// 定義循環隊列
// 如何確定隊空，還是隊滿？q.sendx = (q.sendx+1) % q.dataqsiz
type queue struct {
 buf      []int // 隊列元素存儲
 dataqsiz uint  // circular 隊列長度
 qcount   uint  // 有多少元素在buf中 qcount = len(buf)
 sendx    uint  // 可以理解為隊尾指針，向隊列寫入數據
 recvx    uint  // 可以理解為隊頭指針，從隊列讀取數據
}

func makeQ(size int) *queue {
 q := &queue{
  dataqsiz: uint(size),
  buf:      nil,
 }

 q.buf = make([]int, q.dataqsiz)

 return q
}

// 向buf中寫入數據
// 請看 chansend 函數
func (c *queue) insert(ele int) error {
 // 檢查隊列是否有空間
 if c.dataqsiz > 0 && c.qcount == c.dataqsiz {
  return ErrQFull
 }

 // 存入數據
 c.buf[c.sendx] = ele
 c.sendx++                  // 尾指針后移
 if c.sendx == c.dataqsiz { // 如果相等，說明隊列寫滿了，sendx放到開始位置
  c.sendx = 0
 }
 c.qcount++

 return nil
}

// 從buf中讀取數據
func (c *queue) read() (int, error) {
 // 隊列中沒有數據了
 if c.dataqsiz > 0 && c.qcount == 0 {
  return 0, ErrQEmpty
 }

 ret := c.buf[c.recvx] // 取出元素
 c.buf[c.recvx] = 0
 c.recvx++
 if c.recvx == c.dataqsiz { // 如果相等，說明寫到末尾了，recvx放到開始位置
  c.recvx = 0
 }
 c.qcount--

 return ret, nil
}