# Go学习-Day9

• 个人博客：CSDN博客

Channel

• Channel本质是一个队列
• 多goroutine访问时不需要加锁，Channel天然线程安全
• channel有类型，只能写入相同类型
• channel是引用类型
• channel必须初始化才能写入数据，make分配内存

声明

• 	var intChan chan int
  	intChan = make(chan int, 3)
  

• java不是很熟悉，感觉chan有点像java的原子类

存入取出

• intChan<- xxx //存入
  a := <= intChan//取出
  

• 管道不会自然增长，不能超过容量，不能从空的管道里取出数据，会上DeadLock

• 如果想要存储任意类型的管道，可以用空借口

• var allChan chan interface{}
  

• 但是，取出的时候注意类型断言

• close(intChan)
  

• channel关闭之后就不能再写入了，但是能继续读出

• 关闭之后能用for-range来遍历，如果不关闭的话会出现死锁

• 死锁的情况很多，建议多找几篇文章看看，写写实操一下

• 空的缓冲chan相当于无缓冲的chan，无缓冲的chan需要接收者，传入者，否则就会死锁，注意及时关闭

• 只向管道内写入，不读取就会deadlock，读得慢没有关系

• 关键是要给每个管道安排一个发送者，和接收者！！！

一个简单的死锁分析

package main

import (
	"fmt"
	"time"
)

func write(intChan chan int) {
	for i := 0; i < 5; i++ {
		fmt.Println("写入: ", i)
		intChan <- i
		time.Sleep(time.Second)
	}
	//close(intChan)
}

func read(intChan chan int, exitChan chan bool) {
	for {
		val, ok := <-intChan
		if !ok {
			break
		}
		fmt.Println("读到", val)
	}
	exitChan <- true
	close(exitChan)
}
func main() {

	intChan := make(chan int, 20)
	exitChan := make(chan bool, 1)
	go write(intChan)
	go read(intChan, exitChan)

	for {
		_, ok := <-exitChan
		if !ok {
			break
		}
	}
}

• 输出

写入:  0
读到 0
写入:  1
读到 1
写入:  2
读到 2
写入:  3
读到 3
写入:  4
读到 4
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
        E:/JetBrains/GoLandSpace/src/go_code/project01/main/hello.go:36 +0xe8

goroutine 7 [chan receive]:
main.read(0x0?, 0x0?)
        E:/JetBrains/GoLandSpace/src/go_code/project01/main/hello.go:19 +0x99
created by main.main
        E:/JetBrains/GoLandSpace/src/go_code/project01/main/hello.go:33 +0xd9

Process finished with the exit code 2

• 下面是个人的分析，不一定对，有大佬可以来指正
• 如果我们不close，channel是可以读的，我们可以边读，边写，并且，读的速度是可以更慢或者更快的，go底层会通过上下文自行判断。
• 但是这里，我们写的协程，我们关闭channel，在程序运行完之后自行关闭，此时我们读的协程会卡在intChan，等待读入，但是此时还不会报错，因为协程会因为主线程结束而结束。但是后面的exitChan会导致报错

package main

import (
	"fmt"
	"time"
)

func write(intChan chan int) {
	for i := 0; i < 5; i++ {
		fmt.Println("写入: ", i)
		intChan <- i
		time.Sleep(time.Second)
	}
	//close(intChan)
}

func read(intChan chan int, exitChan chan bool) {
	for {
		val, ok := <-intChan
		if !ok {
			break
		}
		fmt.Println("读到", val)
	}
	fmt.Println("到了这里")
	//exitChan <- true
	//close(exitChan)
}
func main() {

	intChan := make(chan int, 20)
	exitChan := make(chan bool, 1)
	go write(intChan)
	go read(intChan, exitChan)

	time.Sleep(time.Second * 10)
	//for {
	//	_, ok := <-exitChan
	//	if !ok {
	//		break
	//	}
	//}
}

• 这样并没有报错，并且发现到了这里没有打印，说明read函数作为intChan的接收者一直在等待，这时候。

• 但是，主线程运行到下面的for的时候，此时exitChan是空的，因为intChan一直在死循环等待，所以触发了死锁

• 只读只写

• var chanIn chan<- int//只写
  

• var chanOut <-chan int//只读
  

• select {case …}可以安全地取出数据

• 使用recover捕获协程终端 panic