聊聊协程和管道—管道

作者：菜园子dz 2023-08-08 07:18:17开发 前端 使用内置函数close可以关闭管道，聊聊当管道关闭后，协程就不能再向管道写数据了，和管但是道管道仍然可以从该管道读取数据。

管道简介

【1】管道（channel）特质介绍：

（1）管道本质就是聊聊一个数据结构-队列

（2）数据是先进先出

（3）自身线程安全，多协程访问时，协程不需要加锁，和管channel本身就是道管道线程安全的

（4）管道有类型的，一个string的聊聊管道只能存放string类型数据

管道入门案例

【1】管道的定义：

var 变量名 chan 数据类型

PS1：chan管道关键字

PS2：数据类型指的是管道的类型，里面放入数据的协程类型，管道是和管有类型的，int类型的道管道管道只能写入整数int

PS3：管道是引用类型，必须初始化才能写入数据，聊聊即make后才能使用

【2】案例：

func main()  { 	//定义管道 、协程 声明管道 ---> 定义一个int类型的和管管道	var intChan chan int	//通过make初始化：管道可以存放3个int类型的数据	intChan = make(chan int, 3)	//证明管道是引用类型：	fmt.Printf("intChan的值: %v \n",intChan)	//向管道存放数据：	intChan <- -10	num := 20	intChan <- num	intChan <- 40	//注意：不能存放大于容量的数据：	// intChan <- -80	//输出管道的长度：	fmt.Printf("管道的实际长度：%v,管道的容量是：%v \n",len(intChan),cap(intChan))	//在管道中读取数据：	num1 := <-intChan	num2 := <-intChan	num3 := <-intChan	fmt.Println(num1)	fmt.Println(num2)	fmt.Println(num3)	//注意：在没有使用协程的情况下，如果管道的数据已经全部取出，那么再取就会报错：	// num4 := <-intChan	// fmt.Println(num4)	fmt.Printf("管道的实际长度：%v,管道的容量是：%v \n",len(intChan),cap(intChan))}

管道的关闭

【1】管道的关闭：

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

【2】案例：

func main()  { 	var intChan chan int	intChan = make(chan int, 3)	intChan <- 10	intChan <- 20	//关闭管道：	close(intChan)	//再次写入数据：--->报错	// intChan <- 30	//当管道关闭后，读取数据是可以的：	num := <- intChan	fmt.Println(num)}

管道的遍历

【1】管道的遍历：

管道支持for-range的方式进行遍历，请注意两个细节

1)在遍历时，如果管道没有关闭，则会出现deadlock的错误

2)在遍历时，如果管道已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

【2】案例：

func main()  { 	var intChan chan int	intChan = make(chan int, 100)	for i := 0; i < 100; i++ { 		intChan <- i	}	//在遍历前，如果没有关闭管道，就会出现deadlock的错误	//所以我们在遍历前要进行管道的关闭	// for v := range intChan { 	// 	fmt.Println("value = ",v)	// }	close(intChan)	//遍历：for-range	for v := range intChan { 		fmt.Println("value = ",v)	}}

协程和管道协同工作案例

【1】案例需求：

请完成协程和管道协同工作的案例，具体要求:

1) 开启一个writeData协程，向管道中写入50个整数.

2) 开启一个readData协程，从管道中读取writeData写入的数据。

3) 注意: writeData和readDate操作的是同一个管道

4) 主线程需要等待writeData和readDate协程都完成工作才能退出

【2】原理图：

package mainimport (	"fmt"	"time"	"sync")var wg sync.WaitGroup//写：func writeData(intChan chan int)  { 	defer wg.Done()	for i := 1; i <= 50; i++ { 		intChan <- i		fmt.Println("写入的数据为：",i)		time.Sleep(time.Second)	}		close(intChan)}//读：func readData(intChan chan int) { 	defer wg.Done()	for v := range intChan { 		fmt.Println("读取的数据为：",v)		time.Sleep(time.Second)	}}func main()  { 	//主线程	//写协程和读协程共同操作同一个管道-》定义管道：	intChan := make(chan int, 50)	wg.Add(2)	//开启读和写的协程：	go writeData(intChan)	go readData(intChan)	//主线程一直在阻塞，什么时候wg减为0了，就停止	wg.Wait()	fmt.Println("读写数据完成...")}

运行结果：

声明只读只写管道

【1】管道可以声明为只读或者只写性质

【2】代码：

package mainimport (	"fmt")func main()  { 	//默认情况下，管道是双向的--》可读可写：	//声明为只写：	// 管道具备<- 只写性质	var intChan chan<- int	intChan = make(chan int, 3)	intChan <- 10	// 报错	// num := <- intChan	fmt.Println("intChan:",intChan)	//声明为只读：	// 管道具备<- 只读性质 	var intChan2 <-chan int	if intChan2 != nil { 		num1 := <- intChan2		fmt.Println("num1:",num1)	}	// 报错	// intChan2 <- 30}

管道的阻塞

【1】当管道只写入数据，没有读取，就会出现阻塞：

package mainimport (	"fmt"	"sync")var wg sync.WaitGroupfunc writeData(intChan chan int)  { 	defer wg.Done()	for i := 1; i < 10; i++ { 		intChan <- i		fmt.Println("写入的数据：",i)	}	close(intChan)}func readData(intChan chan int)  { 	defer wg.Done()	for v := range intChan { 		fmt.Println("读取的数据为：",v)	}}func main()  { 	intChan := make(chan int, 10)	wg.Add(2)	go writeData(intChan)	// go readData(intChan)	wg.Wait()}

运行结果

【2】写的快，读的慢（管道读写频率不一致），不会出现阻塞问题：

package mainimport (	"fmt"	"sync"	"time")var wg sync.WaitGroupfunc writeData(intChan chan int)  { 	defer wg.Done()	for i := 1; i < 10; i++ { 		intChan <- i		fmt.Println("写入的数据：",i)	}	close(intChan)}func readData(intChan chan int)  { 	defer wg.Done()	for v := range intChan { 		fmt.Println("读取的数据为：",v)		time.Sleep(time.Second)	}}func main()  { 	intChan := make(chan int, 10)	wg.Add(2)	go writeData(intChan)	go readData(intChan)	wg.Wait()}

select功能

【1】select功能：解决多个管道的选择问题，也可以叫做多路复用，可以从多个管道中随机公平地选择一个来执行

PS：case后面必须进行的是io操作，不能是等值，随机去选择一个io操作

PS：default防止select被阻塞住，加入default

【2】代码：

package mainimport (	"fmt"	"time")func main()  { 	intChan := make(chan int, 1)	go func ()  { 		time.Sleep(time.Second * 15)		intChan <- 15	}()	stringChan := make(chan string, 1)	go func ()  { 		time.Sleep(time.Second * 12)		stringChan <- "hellocyz"	}()	//本身取数据就是阻塞的	// fmt.Println(<-intChan)	select { 		case v := <-intChan : fmt.Println("intChan:",v)		case v := <-stringChan : fmt.Println("stringChan:",v)		default: fmt.Println("防止select被阻塞")	}}

defer+recover机制处理错误

【1】问题原因：多个协程工作，其中一个协程出现panic，导致程序崩溃

【2】解决办法：利用defer+recover捕获panic进行处理，即使协程出现问题，主线程仍然不受影响可以继续执行。

【3】案例：

package mainimport (	"fmt"	"time")//输出数字：func printNum()  { 	for i := 1; i <= 10; i++ { 		fmt.Println(i)		}}//做除法操作：func divide()  { 	defer func ()  { 		err := recover()		if err != nil { 			fmt.Println("devide()出现错误：",err)		}	}()	num1 := 10	num2 := 0	result := num1 / num2	fmt.Println(result)}func main()  { 	//启动两个协程：	go printNum()	go divide()	time.Sleep(time.Second * 5)}

结果：

责任编辑：武晓燕 来源： 今日头条 协程管道函数

(责任编辑：探索)