goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存，而不是共享内存来通信。

引⽤类型 channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。

11.3.1 channel类型

和map类似，channel也一个对应make创建的底层数据结构的引用。

当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者何被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。

定义一个channel时，也需要定义发送到channel的值的类型。channel可以使用内置的make()函数来创建：

  1.     make(chan Type) //等价于make(chan Type, 0)
  2.     make(chan Type, capacity)

当 capacity= 0 时，channel 是无缓冲阻塞读写的，当capacity> 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity个元素才阻塞写入。

channel通过操作符<-来接收和发送数据，发送和接收数据语法：

  1.     channel <- value      //发送value到channel
  2.     <-channel             //接收并将其丢弃
  3.     x := <-channel        //从channel中接收数据，并赋值给x
  4.     x, ok := <-channel    //功能同上，同时检查通道是否已关闭或者是否为空

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变的更加的简单，而不需要显式的lock。

示例代码：

  1. func main() {
  2.     c := make(chan int)
  4.     go func() {
  5.         defer fmt.Println("子协程结束")
  7.         fmt.Println("子协程正在运行……")
  9.         c <- 666 //666发送到c
  10.     }()
  12.     num := <-c //从c中接收数据，并赋值给num
  14.     fmt.Println("num = ", num)
  15.     fmt.Println("main协程结束")
  16. }

11.3.2 无缓冲的channel

无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。

这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。如果两个goroutine没有同时准备好，通道会导致先执行发送或接收操作的 goroutine 阻塞等待。

这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

下图展示两个 goroutine 如何利用无缓冲的通道来共享一个值：

  • 在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。
  • 在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。
  • 在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。
  • 在第 4 步和第 5 步，进行交换，并最终，在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。

无缓冲的channel创建格式：

  1. make(chan Type) //等价于make(chan Type, 0)

如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收。

示例代码：

  1. func main() {
  2.     c := make(chan int, 0) //无缓冲的通道
  4.     //内置函数 len 返回未被读取的缓冲元素数量， cap 返回缓冲区大小
  5.     fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
  7.     go func() {
  8.         defer fmt.Println("子协程结束")
  10.         for i := 0; i < 3; i++ {
  11.             c <- i
  12.             fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\n", i, len(c), cap(c))
  13.         }
  14.     }()
  16.     time.Sleep(2 * time.Second) //延时2s
  18.     for i := 0; i < 3; i++ {
  19.         num := <-c //从c中接收数据，并赋值给num
  20.         fmt.Println("num = ", num)
  21.     }
  23.     fmt.Println("main协程结束")
  24. }

11.3.3 有缓冲的channel

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。

这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。
示例图如下：

  • 在第 1 步，右侧的 goroutine 正在从通道接收一个值。
  • 在第 2 步，右侧的这个 goroutine独立完成了接收值的动作，而左侧的 goroutine 正在发送一个新值到通道里。
  • 在第 3 步，左侧的goroutine 还在向通道发送新值，而右侧的 goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的，也不会互相阻塞。
  • 最后，在第 4 步，所有的发送和接收都完成，而通道里还有几个值，也有一些空间可以存更多的值。

有缓冲的channel创建格式：

  1.  make(chan Type, capacity)

如果给定了一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。

示例代码：

  1. func main() {
  2.     c := make(chan int, 3) //带缓冲的通道
  4.     //内置函数 len 返回未被读取的缓冲元素数量， cap 返回缓冲区大小
  5.     fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
  7.     go func() {
  8.         defer fmt.Println("子协程结束")
  10.         for i := 0; i < 3; i++ {
  11.             c <- i
  12.             fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\n", i, len(c), cap(c))
  13.         }
  14.     }()
  16.     time.Sleep(2 * time.Second) //延时2s
  17.     for i := 0; i < 3; i++ {
  18.         num := <-c //从c中接收数据，并赋值给num
  19.         fmt.Println("num = ", num)
  20.     }
  21.     fmt.Println("main协程结束")
  22. }

11.3.4 range和close

如果发送者知道，没有更多的值需要发送到channel的话，那么让接收者也能及时知道没有多余的值可接收将是有用的，因为接收者可以停止不必要的接收等待。这可以通过内置的close函数来关闭channel实现。

示例代码：

  1. func main() {
  2.     c := make(chan int)
  4.     go func() {
  5.         for i := 0; i < 5; i++ {
  6.             c <- i
  7.         }
  8.         //把 close(c) 注释掉，程序会一直阻塞在 if data, ok := <-c; ok 那一行
  9.         close(c)
  10.     }()
  12.     for {
  13.         //ok为true说明channel没有关闭，为false说明管道已经关闭
  14.         if data, ok := <-c; ok {
  15.             fmt.Println(data)
  16.         } else {
  17.             break
  18.         }
  19.     }
  21.     fmt.Println("Finished")
  22. }

注意点：

  • channel不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel；
  • 关闭channel后，无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)；
  • 关闭channel后，可以继续向channel接收数据；
  • 对于nil channel，无论收发都会被阻塞。

可以使用 range 来迭代不断操作channel：

  1. func main() {
  2.     c := make(chan int)
  4.     go func() {
  5.         for i := 0; i < 5; i++ {
  6.             c <- i
  7.         }
  8.         //把 close(c) 注释掉，程序会一直阻塞在 for data := range c 那一行
  9.         close(c)
  10.     }()
  12.     for data := range c {
  13.         fmt.Println(data)
  14.     }
  15.     fmt.Println("Finished")
  16. }

11.3.5 单方向的channel

默认情况下，通道是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。

但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。

单向channel变量的声明非常简单，如下：

  1. var ch1 chan int       // ch1是一个正常的channel，不是单向的
  2. var ch2 chan<- float64 // ch2是单向channel，只用于写float64数据
  3. var ch3 <-chan int     // ch3是单向channel，只用于读取int数据
  • chan<- 表示数据进入管道，要把数据写进管道，对于调用者就是输出。
  • <-chan 表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入。

可以将 channel 隐式转换为单向队列，只收或只发，不能将单向 channel 转换为普通 channel：

  1.     c := make(chan int, 3)
  2.     var send chan<- int = c // send-only
  3.     var recv <-chan int = c // receive-only
  4.     send <- 1
  5.     //<-send //invalid operation: <-send (receive from send-only type chan<- int)
  6.     <-recv
  7.     //recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)
  9.     //不能将单向 channel 转换为普通 channel
  10.     d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
  11.     d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int

示例代码：

  1. //   chan<- //只写
  2. func counter(out chan<- int) {
  3.     defer close(out)
  4.     for i := 0; i < 5; i++ {
  5.         out <- i //如果对方不读 会阻塞
  6.     }
  7. }
  9. //   <-chan //只读
  10. func printer(in <-chan int) {
  11.     for num := range in {
  12.         fmt.Println(num)
  13.     }
  14. }
  16. func main() {
  17.     c := make(chan int) //   chan   //读写
  19.     go counter(c) //生产者
  20.     printer(c)    //消费者
  22.     fmt.Println("done")
  23. }

11.3.6 定时器

11.3.6.1 Timer

Timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个channel，在将来的那个时间那个channel提供了一个时间值。

示例代码：

  1. import "fmt"
  2. import "time"
  4. func main() {
  5.     //创建定时器，2秒后，定时器就会向自己的C字节发送一个time.Time类型的元素值
  6.     timer1 := time.NewTimer(time.Second * 2)
  7.     t1 := time.Now() //当前时间
  8.     fmt.Printf("t1: %v\n", t1)
  10.     t2 := <-timer1.C
  11.     fmt.Printf("t2: %v\n", t2)
  13.     //如果只是想单纯的等待的话，可以使用 time.Sleep 来实现
  14.     timer2 := time.NewTimer(time.Second * 2)
  15.     <-timer2.C
  16.     fmt.Println("2s后")
  18.     time.Sleep(time.Second * 2)
  19.     fmt.Println("再一次2s后")
  21.     <-time.After(time.Second * 2)
  22.     fmt.Println("再再一次2s后")
  24.     timer3 := time.NewTimer(time.Second)
  25.     go func() {
  26.         <-timer3.C
  27.         fmt.Println("Timer 3 expired")
  28.     }()
  30.     stop := timer3.Stop() //停止定时器
  31.     if stop {
  32.         fmt.Println("Timer 3 stopped")
  33.     }
  35.     fmt.Println("before")
  36.     timer4 := time.NewTimer(time.Second * 5) //原来设置3s
  37.     timer4.Reset(time.Second * 1)            //重新设置时间
  38.     <-timer4.C
  39.     fmt.Println("after")
  40. }

11.3.6.2 Ticker

Ticker是一个定时触发的计时器，它会以一个间隔(interval)往channel发送一个事件(当前时间)，而channel的接收者可以以固定的时间间隔从channel中读取事件。

示例代码：

  1. func main() {
  2.     //创建定时器，每隔1秒后，定时器就会给channel发送一个事件(当前时间)
  3.     ticker := time.NewTicker(time.Second * 1)
  5.     i := 0
  6.     go func() {
  7.         for { //循环
  8.             <-ticker.C
  9.             i++
  10.             fmt.Println("i = ", i)
  12.             if i == 5 {
  13.                 ticker.Stop() //停止定时器
  14.             }
  15.         }
  16.     }() //别忘了()
  18.     //死循环，特地不让main goroutine结束
  19.     for {
  20.     }
  21. }
作者：admin  创建时间：2018-06-18 06:50
 更新时间：2018-06-18 07:04
上一篇：
下一篇：