Go语言入门学习之Channel通道详解

目录

• 前言
• 通道的声明
• 通道的初始化
• 发送和接收数据
• 通道的关闭
• 通道的容量与长度
• 缓冲通道与无缓冲通道
• 双向通道和单向通道
• 遍历通道
• fibonacci 数列
• 参考文章：
• 总结

前言

不同于传统的多线程并发模型使用共享内存来实现线程间通信的方式，go 是通过 channel 进行协程 (goroutine) 之间的通信来实现数据共享。

channel，就是一个管道，可以想像成 Go 协程之间通信的管道。它是一种队列式的数据结构，遵循先入先出的规则。

通道的声明

每个通道都只能传递一种数据类型的数据，声明时需要指定通道的类型。chan Type 表示 Type 类型的通道。通道的零值为 nil 。

var channel_name chan channel_types 

var str chan string 

通道的初始化

声明完通道后，通道的值为 nil ，不能直接使用，使用 make 函数对通道进行初始化操作。

channel_name = make(chan channel_type) 

str = make(chan string) 

或者

str := make(chan string) 

发送和接收数据

发送数据，把 data 数据发送到 channel_name 通道中。

channel_name <- data 

接收数据，从 channel_name 通道中接收数据到 value。

value := <- channel_name 

func PrintFunc(c chan string) {
   c <- "往通道里面传数据"
}

func main() {
   str := make(chan string)
   fmt.Println("start")
   go PrintFunc(str)
   result := <-str
   fmt.Println(result)
   fmt.Println("end")
}

发送与接收默认是阻塞的。如果从通道接收数据没接收完主协程是不会继续执行下去的。当把数据发送到通道时，会在发送数据的语句处发生阻塞，直到有其它协程从通道读取到数据，才会解除阻塞。与此类似，当读取通道的数据时，如果没有其它的协程把数据写入到这个通道，那么读取过程就会一直阻塞着。

通道的关闭

对于一个已经使用完毕的通道，我们要将其进行关闭。对于一个已经关闭的通道如果再次关闭会导致报错。

close(channel_name) 

可以在接收数据时，判断通道是否已经关闭，从通道读取数据返回的第二个值表示通道是否没被关闭，如果已经关闭，返回值为 false ；如果还未关闭，返回值为 true 。

value, ok := <- channel_name 

通道的容量与长度

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小

ch := make(chan int, 100)

• 0：通道中不能存放数据，在发送数据时，必须要求立马接收，否则会报错。此时的通道称之为无缓冲通道。
• 1：通道只能缓存一个数据，若通道中已有一个数据，此时再往里发送数据，会造成程序阻塞。利用这点可以利用通道来做锁。
• 大于 1 ：通道中可以存放多个数据，可以用于多个协程之间的通信管道，共享资源。

通过 cap 函数和 len 函数获取通道的容量和长度。

func main() {
   // 创建一个通道
   c := make(chan int, 5)
   fmt.Println("初始化：")
   fmt.Println("cap：", cap(c))
   fmt.Println("len：", len(c))
   c <- 1
   c <- 2
   c <- 3
   fmt.Println("传入数据：")
   fmt.Println("cap：", cap(c))
   fmt.Println("len：", len(c))
   <-c
   fmt.Println("取出一个数：")
   fmt.Println("cap：", cap(c))
   fmt.Println("len：", len(c))
}

缓冲通道与无缓冲通道

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

c := make(chan int) 
// 或者 
c := make(chan int, 0) 

缓冲通道允许通道里存储一个或多个数据，设置缓冲区后，发送端和接收端可以处于异步的状态。

c := make(chan int, 3) 

双向通道和单向通道

双向通道：既可以发送数据也可以接收数据

func main() {
   // 创建一个通道
   c := make(chan int)

   // 发送数据
   go func() {
      fmt.Println("send: 1")
      c <- 1
   }()

   // 接收数据
   go func() {
      n := <-c
      fmt.Println("receive:", n)
   }()

   // 主协程休眠
   time.Sleep(time.Millisecond)
}

单向通道：只能发送或者接收数据。具体细分为只读通道和只写通道。

<-chan 表示只读通道：

// 定义只读通道
c := make(chan string)
// 定义类型
type Receiver = <-chan string
var receiver Receiver = c

// 或者简单写成下面的形式
type Receiver = <-chan int
receiver := make(Receiver)

chan<- 表示只写通道：

// 定义只写通道
c := make(chan int)
// 定义类型
type Sender = chan<- int
var sender Sender = c

// 或者简单写成下面的形式
type Sender = chan<- int
sender := make(Sender)

package main

import (
   "fmt"
   "time"
)

// Sender 只写通道类型
type Sender = chan<- string

// Receiver 只读通道类型
type Receiver = <-chan string

func main() {
   // 创建一个双向通道
   var ch = make(chan string)

   // 开启一个协程
   go func() {
      // 只写通道
      var sender Sender = ch
      fmt.Println("write only start:")
      sender <- "Go"
   }()

   // 开启一个协程
   go func() {
      // 只读通道
      var receiver Receiver = ch
      message := <-receiver
      fmt.Println("readonly start: ", message)
   }()

   time.Sleep(time.Millisecond)
}

遍历通道

使用 for range 循环可以遍历通道，但在遍历时要确保通道是处于关闭状态，否则循环会被阻塞。

package main

import (
   "fmt"
)

func loopPrint(c chan int) {
   for i := 0; i < 10; i++ {
      c <- i
   }
   // 记得要关闭通道
   // 否则主协程遍历完不会结束，而会阻塞
   close(c)
}

func main() {
   // 创建一个通道
   var ch2 = make(chan int, 5)
   go loopPrint(ch2)
   for v := range ch2 {
      fmt.Println(v)
   }
}

fibonacci 数列

package main

import (
   "fmt"
)

func fibonacci(n int, c chan int) {
   x, y := 0, 1
   for i := 0; i < n; i++ {
      c <- x
      x, y = y, x+y
   }
   close(c)
}

func main() {
   c := make(chan int, 10)
   go fibonacci(cap(c), c)
   // range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个
   // 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据
   // 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不
   // 会结束，从而在接收第 11 个数据的时候就阻塞了。
   for i := range c {
      fmt.Println(i)
   }
}

参考文章：

go-edu.cn/

www.runoob.com/go/go-tutor…

总结