在上一篇文章中，我们介绍了 Go 并发编程的基础—goroutine，同时也介绍 goroutine 的几种使用方式，但没有说明 goroutine 之间是如何通信的。

Go 语言中有一句经典的话，不要通过共享内存来通信，而应该通过通信来共享内存。这个原则让 channel 成为了 Go 语言中非常重要的一个组件。

goroutine 之间的通信主要是通过 channel 来完成的，这篇文章中，我们来认识一下 channel，以及channel 的基本使用。

1. 什么是通道（channel）

Go 语言中，并发模式有两种实现方式，一种是传统的通过锁和信号量等手段，来实现对个共享变量（内存）的同步访问，从而实现并发。还有一种通过 goroutine + channel 的组合方式，传递值的方式来实现并发。

goroutine + channel 是对 CSP（Communicating Sequential Process）模式的一种实现。CSP 模式中，有两个核心的概念，process 和 channel，process 对应 groutine，所有的 process 之间的通信通过 channel 来实现。

channel 是可以被单独创建的，可以用来连接任意两个 goroutine，channel 也有自己的数据类型，被称之为通道的元素类型。

创建一个通道很简单，比如下面创建了传递 int 值的通道:

ch := make(chan int)

chan 表示通道，int 表示通道中传递的元素类型，使用 make 就可以创建一个新的通道。make 返回的结果是通道的引用，当复制这个通道或者把通道作为函数参数的时候，传递的都是引用，这点很重要，需要重点理解一下。这里顺便说一下，channel 是可比较的，也就是说可以通过 == 来比较。

通道有两个操作，一个是发送，一个是接收，都使用 <- 来表示，区别在于发送时，通道在前，接收时通道在后。向一个通道中发送数据：

x := 5
ch <- x

从通道中接收一个结果，如果不把结果赋值给一个变量，结果就会被抛弃，这样也是合法的：

x := <-ch
<-ch // 这样也是合法的

一个完整的发送和接收的例子如下：

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func() {
        x := 5
        ch <- x
    }()

    y := <-ch
    fmt.Println(y)
}

在使用通道的过程中，可能会出现死锁，具体的原因我们下文再详细说。对于通道来说，还有一个操作，就是关闭通道，对于一个已经关闭的 channel，无法再发送数据，否则会发生 panic，但是可以进行接收操作，下面的程序可以正常运行：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)

    go func() {
        x := 5
        ch <- x
        close(ch)
    }()

    y := <-ch
    fmt.Println(y)
}

2. 无缓冲通道

上面用来创建通道的 make 其实还有第二个参数，用来指定通道容量。如果不指定这个参数或者指定的参数是 0，那么就表示这个通道是无缓冲通道：

// 下面两种创建方式是等价的
ch := make(chan int)
ch := make(chan int, 0)

在无缓冲通道上的发送操作会阻塞，直到接收端的接收操作完成，然后才会继续执行。在上一篇文章中，我们为了解决主 goroutine 等待子 goroutine 执行完成用的就是这个方法。代码如下：

func goroutine2(isDone chan bool) {
    fmt.Println("child goroutine begin...")
    time.Sleep(2 * time.Second)
    fmt.Println("child goroutine end...")
    isDone <- true
}

func main() {
    isDone := make(chan bool)
    go goroutine2(isDone)
    <-isDone
    fmt.Println("main goroutine end..")
}

所以对于无缓冲通道来说，不能在同一个 goroutine 中使用，否则会造成死锁。关于死锁的问题，下文再详细讨论。

3. 缓冲通道

在创建缓冲通道时，需要指定通道的容量：

ch := make(chan int, 3)

上面的代码创建了容量为 3 的通道，可以直接向通道中发送值，发送的前 3 个操作不会阻塞：

ch <- 1
ch <- 2
ch <- 3

如果在发送的过程中，如果接收端没有接收，那么此时通道就是满的，在发送第 4 个值的时候就会阻塞。

对于缓冲通道，可以使用 cap 方法得到通道的容量，可以使用 len 方法得到当前通道中元素的个数：

cap(ch) // 获取容量
len(ch) // 获取元素个数

对于一个缓冲通道，在同一个 goroutine 中使用也有造成死锁的风险，所以最好不要在同一个 goroutine 中使用通道。

4. 单向通道

在默认情况下，创建的通道可以发送数据，可以接受数据，但是在一些情况下，我们值需要通道的发送或者接收能力。这个时候，就需要单向通道。

单向通道的表示起来很简单，把 <- 放在 chan 前，表示只接收，放在 chan 后表示只发送：

sendCh := male(chan<- int) // 表示只发送的通道
recCh := make(<-chan int) // 表示只接收的通道

但实际的使用中，我们不需要去创建这种单向通道，只是在某些情况下，我们把通道转成单向通道就行。比如下面的代码中，在 sendData 方法中，我只需要用到通道的发送能力，所以可以通道改成发送的单向通道，其他人阅读代码的时候，也更能理解：

func main() {
    ch := make(chan int, 10)
    sendData(ch)
}

func sendData(sendCh chan<- int) {
    for i := 0;i < 10; i++ {
        sendCh <- i
    }
}

双向通道可以转成转成单向通道，但反过来却不行。

5. 小结

这篇文章介绍了通道，通道对于 Go 语言来说很重要，是实现高并发的基础，通道为 goroutine 之间提供了一种高效安全的通信方式。但在使用通道的时候需要注意死锁问题。

文 / Rayjun
本文首发于微信公众号【Rayjun】