Go语言并发编程(三)——初窥管道_go模板管道命令入参是第一个-CSDN博客

本文链接：https://blog.csdn.net/qq_73924465/article/details/137679740

管道(channel)

前言

go语言对管道作用的解释是这样的:通过消息实现内存共享,channel就是为此而生的，
与c++实现并发编程中利用共享内存进行多线程/进程通信不同，go语言通道的思想就是
协程与协程之间并不创建实质上的共享,而是基于管道的通信，实现多个协程之间共享内存。
在Go语言中，我们会通过关键字chan来声明一个管道，同时我们也要指定其存储的数
据是什么类型，例如下面我们可以尝试创建一个简单的管道:

var ch chan int

当然这只是一个管道的声明,此时管道还没有初始化,其值为nil

管道的创建

创建管道只有一个方法,使用内置函数make，对于管道而言，main函数接收两个参数
第一个是管道的类型,第二个是可选参数为管道的缓冲大小。例子:

intCh:=make(chan int)
strCh:=make(chan string,1)

我们在使用完一个管道之后记得关闭该管道,使用close函数来关闭该管道,函数签名为:

func close(c<-chan Type)

示例:

func main(){
	intCh:=make(chan int)
	close(intCh))
}

有时候我们也可以用defer来优雅的关闭

管道的读写

对于一个管道而言,Go使用了两种很形象的操作符来表示读写操作:

<-:表示管道的读操作
<-:表示管道的写操作
<-很生动的表示了数据的流动方向，我们来看一个int类型的管道读写的例子:

package main

import "fmt"

func main() {
	var ch chan int
	ch = make(chan int, 1)
	defer close(ch)
	ch <- 1
	a := <-ch
	fmt.Println(a)
}

输出结果:

管道里面数据的流动方式与队列相似，都是先进先出，协程对管道的操作是同步的,在某一
时刻只有一个协程可以写管道，同时也只有一个协程读管道中的数据。

无缓冲管道

对于无缓冲管道而言,因为我们所设置的缓冲区容量为0，所以缓冲区里面不会存放任何数据，
由于缓冲区不能缓存任何数据，所以向管道里面写入数据时必须立刻就有其他协程来读取数据，
否则就会阻塞,读也是同理，这也解释了下面这个代码为什么会出现死锁:

package main

import "fmt"

func main() {
	var ch chan int
	ch = make(chan int)
	defer close(ch)
	ch <- 1
	a := <-ch
	fmt.Println(a)
}

我们在使用无缓冲管道时,为了保证读写操作的一致，一般会采取再使用一个协程来进行数据
的读/写

package main

import "fmt"

func main() {
	var ch chan int
	ch = make(chan int)
	defer close(ch)
	go func() {
		ch <- 1
	}()
	n := <-ch
	fmt.Println(n)
}

输出结果:

有缓存管道

有缓冲管道的基本使用

当我们使用有缓存管道时，会为管道设置缓冲区大小，当管道有了缓冲区，就像是一个阻塞
队列一样，当队列已满/为空时,协程都会阻塞，。无缓冲管道在发送数据时，必须立刻有人
接收，否则就会一直阻塞。对于有缓冲管道则不必如此，对于有缓冲管道写入数据时会先将
数据放入缓冲区，当缓冲区满了才会阻塞等待协程来读取管道中的数据，同理我们在读数据的
时候，会先从缓冲区中读取数据，直到缓冲区没数据了，才会阻塞的等待协程来向管道中写入
数据。所以上面的无缓冲死锁代码稍作修改在这里就可以运行:

func main() {
   // 创建有缓冲管道
   ch := make(chan int, 1)
   defer close(ch)
   // 写入数据
   ch <- 123
   // 读取数据
   n := <-ch
   fmt.Println(n)
}

不过这种同步读写的方式是很危险的，一但缓冲区满/空了，可能就会永远堵塞。因为可能
没有其他协程来写入/读取数据，比如下面这个例子:

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int, 5)
	chW := make(chan struct{})
	chR := make(chan struct{})

	defer func() {
		close(ch)
		close(chW)
		close(chR)
	}()

	go func() {
		for i := 0; i < 10; i++ {
			ch <- i
			fmt.Println("write", i)
		}
		chW <- struct{}{}
	}()

	go func() {
		for i := 0; i < 10; i++ {
			time.Sleep(time.Second * 10)
			fmt.Println("read", <-ch)
		}
		chR <- struct{}{}
	}()
	fmt.Println("Write done", <-chW)
	fmt.Println("Read done", <-chR)
}

这里我们创建了三个管道，一个有缓冲管道来进行协程间的通信,两个无缓冲管道来实现协程
之间的同步,负责读的协程每次读取之前都会等待1毫秒，负责写的协程一口气做多也只能写入
5个数据，因为管道缓冲区最大只有5，在没有协程来读取之前，只能阻塞等待,所以其输出为:

write 0
write 1
write 2
write 3
write 4
read 0
write 5
read 1
write 6
read 2
write 7
read 3
write 8
read 4
write 9
Write done {}
read 5
read 6
read 7
read 8
read 9
Read done {}

可以看到负责写的协程刚开始就一口气发送了5个数据，缓冲区满了以后就开始阻塞等待读协
程来读取，后面就是每当读协程1毫秒读取一个数据，缓冲区有空位了，写协程就写入一个数
据，直到所有数据发送完毕，写协程执行结束，随后当读协程将缓冲区所有数据读取完毕后，
读协程也执行结束，最后主协程退出。

补充

len函数与cap函数的使用
我们可以通过内置函数len来获取管道缓冲区中数据的个数或者通过cap函数来访问管道
缓冲区的大小
示例:

package main

import "fmt"

func main() {
	ch := make(chan int, 5)
	defer close(ch)
	for i := 0; i < 4; i++ {
		ch <- i
	}
	fmt.Println(len(ch))
	fmt.Println(cap(ch))
}

输出为:

4
5

基于管道的阻塞.实现父子协程的同步

package main

import (
	"fmt"
	"sync"
	"time"
)

var chR = make(chan struct{})

func main() {
	var wait sync.WaitGroup
	wait.Add(1)
	defer func() {
		close(chR)
	}()
	go func() {
		chR <- struct{}{}
		fmt.Println(1)
		wait.Done()
	}()
	time.Sleep(time.Second * 10)
	fmt.Println(2)
	fmt.Println(<-chR)
	wait.Wait()
}

输出为

2
1
{}

我们还可以基于有缓冲管道实现一个简单的互斥锁

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wait sync.WaitGroup
	wait.Add(2)
	var count = 0
	mutex := make(chan struct{}, 1)
	done := make(chan bool, 2)

	go func() {
		mutex <- struct{}{} // 加锁
		for i := 0; i < 10; i++ {
			count++
		}
		<-mutex // 解锁
		done <- true
	}()

	go func() {
		mutex <- struct{}{}
		for i := 0; i < 7; i++ {
			count--
		}
		<-mutex
		done <- true
	}()

	go func() {
		<-done
		wait.Done()
	}()

	go func() {
		<-done
		wait.Done()
	}()

	wait.Wait()
	fmt.Println(count)
}