基本介绍

  • channel本质就是一个数据结构——队列
  • 数据是先进先出
  • 线程安全，多 goroutine 访问时，不需要加锁
  • channel是有类型的（string，int，interface 类型断言）

image.png

定义声明channel

  1. var 变量名 chan 数据类型
  3. var intChan chan int // intChan 用于存放 int 数据
  4. var mapChan chan map[int]string // mapChan 用于存放 map[int]string 类型数据
  5. var perChan chan Person // 结构体
  6. var perChan chan *Person // 结构体指针
  1. channel 是引用类型
  2. channel 必须初始化才能写入数据，即 make 后才能使用
  3. channel 是有类型的， （比如： intChan 只能写入 int 类型数据）
  4. channel 中的数据取完之后，再继续取就会报死锁： fatal error: all goroutines are asleep - deadlock!

代码

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // 1、声明 chan 类型的数据，存放 3 个int
  7.     var intChan chan int
  8.     fmt.Println("intChan =", intChan) // nil
  10.     // 2、初始化
  11.     intChan = make(chan int, 3)
  12.     // intChan类型： chan int, 值： 0xc00001c100 , 本身的地址： 0xc000006028
  13.     fmt.Printf("intChan类型： %T, 值： %v , 本身的地址： %v\n", intChan, intChan, &intChan)
  14.     // 3、向管道（channel）写入数据
  15.     // 注意： 写入数据时，不能超过其容量，fatal error: all goroutines are asleep - deadlock!
  16.     // 致命错误：所有goroutine都处于休眠状态-死锁！
  17.     intChan <- 10
  18.     num := 211
  19.     intChan <- num
  20.     intChan <- 12
  21.     // 4、查看channel的长度和容量
  22.     fmt.Printf("intChan长度： %v, 容量： %v \n", len(intChan), cap(intChan))
  23.     // 5、读取 channel - 队列（先进先出FIFO）
  24.     var num2 int = <-intChan
  25.     fmt.Println("num2 = ", num2)
  26.     fmt.Printf("intChan长度： %v, 容量： %v \n", len(intChan), cap(intChan))
  27.     // 6、在没有使用协程的情况下，如果我们的管道数据已经全部取出，再继续取就会报 deadlock (死锁)
  28.     num3 := <-intChan
  29.     num4 := <-intChan
  30.     // num5 := <-intChan // channel 里已经没有数据，不能再取了 fatal error: all goroutines are asleep - deadlock!
  31.     fmt.Println("num3 = ", num3, "num4 = ", num4)
  32. }

interface{} 类型的 channel

任何数据类型都实现了空接口，使用的时候要先断言数据类型

  1. package main
  3. import "fmt"
  5. type Cat struct {
  6.     Name string
  7.     Age  int
  8. }
  10. func main() {
  11.     var allChan chan interface{} = make(chan interface{}, 10)
  12.     allChan <- 10
  13.     cat1 := Cat{Name: "tom", Age: 2}
  14.     cat2 := Cat{Name: "tom02", Age: 3}
  15.     allChan <- cat1
  16.     allChan <- cat2
  17.     allChan <- "jack"
  18.     // 取出
  19.     item := <-allChan
  20.     fmt.Printf("item类型：%T, 值： %v \n", item, item)
  21.     // item类型：int, 值： 10
  22.     // 类型断言
  23.     newItem, ok := item.(Cat)
  24.     fmt.Printf("newItem 类型：%T, 值： %v, ok = %v", newItem, newItem, ok)
  25.     // newItem 类型：main.Cat, 值： { 0}, ok = false
  26. }

channel 的关闭和遍历

channel的关闭

使用内置函数close可以关闭channel,当channel关闭后，就不能再向channel写数据了，但是仍然可以从该channel读取数据。

channel的遍历

channel不能使用常规for循环遍历，因为每取一次数据，channel的长度就减1
channel支持for—range的方式进行遍历，请注意两个细节
1、在遍历时，如果channel没有关闭，则回出现 deadlock 的错误
2、在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

代码

  1. // channel 的关闭和遍历
  2. package main
  4. import "fmt"
  6. func main() {
  7.     // 1、关闭
  8.     intChan := make(chan int, 3)
  9.     intChan <- 100
  10.     intChan <- 200
  11.     close(intChan)
  12.     // intChan <- 300
  13.     // 关闭之后不能写入 panic: send on closed channel
  14.     fmt.Println("intChan = ", intChan) // intChan =  0xc000118080
  15.     // 关闭之后可以读取
  16.     n1 := <-intChan
  17.     fmt.Println("n1 = ", n1) // n1 =  100
  18.     // 2、遍历
  19.     intChan2 := make(chan int, 100)
  20.     for i := 1; i <= 100; i++ {
  21.         intChan2 <- i // 放入100个数据
  22.     }
  23.     // 常规for循环只能遍历取出50个数据 - 因为每取一个，channel 的长度就 -1
  24.     /* for i := 1; i <= len(intChan2); i++ {
  25.         fmt.Printf("第%v个值：%v \n", i, <-intChan2)
  26.     } */
  27.     // for range 遍历, 没有 index
  28.     close(intChan2)
  29.     // 如果遍历时，没有关闭channel, 就会出现死锁 deadlock; 关闭后，则会正常遍历，遍历完之后，退出程序
  30.     for v := range intChan2 {
  31.         fmt.Println("v=", v)
  32.     }
  33. }