《Go程序设计语言》 8 goroutine和通道

本章展示通信顺序进程

goroutine

每一个并发执行的活动称为goroutine，当程序启动时，一个goroutine负责调用main函数，新的goroutine通过go来创建。一个go语句是g 函数(参数)，即立即新建一个goroutine进行该函数的调用

一个简单的例子

func main() {
    go sayHello() // 创建一个新的Goroutine去执行sayHello函数
    time.Sleep(100 * time.Millisecond) // 等待Goroutine执行完成
}

func sayHello() {
    fmt.Println("Hello, world!")
}

通道

通道是用来连接goroutine的，它使得可以让一个goroutine发送特定类型的值到另一个goroutine

创建：chan是引用类型，传递参数时可以直接传，相当于传引用了

ch := make(chan int)

将一个值发送到通道

ch <- x 

接受通道传来的值，该表达式返回通道里的值

<-ch

配合赋值语句的接受

x = <-ch

关闭通道：

• 关闭后向通道发送将导致宕机
• 从关闭后的通道接收：获取已经发送的值，直到通道为空。通道为空后，获取通道元素对应的零值

close(ch)

无缓冲通道

无缓冲通道是指在通道中只能存储一个元素，即在发送者和接收者之间进行同步通信。

无缓冲通道的发送和接收操作是阻塞的，直到发送者和接收者都准备好进行通信时才会完成操作。

无缓冲通道的通信可以视作一种“同步信号”，来进行两个roroutine之间的同步

package main

import "fmt"

func main() {
    ch := make(chan bool)

    go func() {
        fmt.Println("协程1开始执行")
        // 模拟协程1的工作
        for i := 0; i < 5; i++ {
            fmt.Println("协程1正在工作", i)
        }
        fmt.Println("协程1执行完毕")
        // 向通道发送信号
        ch <- true
    }()

    fmt.Println("等待协程1执行完毕")
    // 等待通道接收信号
    <-ch
    fmt.Println("协程1已执行完毕，主协程继续执行")
}

管道

使用通道来连接多个goroutine，使得一个的输出是另一个输入，称为管道

func main() {
	naturals := make(chan int)
	squares := make(chan int)
	//counter
	go func() {
		for x:=0;;x++ {
			naturals <- x
		}
	}()
	//squarer
	go func() {
		for {
			x := <-naturals
			squares <- x*x
		}
	}()
	//printer
	for {
		fmt.Println(<-squares)
	}
}

整个程序的逻辑看起来像是

管道的关闭，需要的是级联关闭各个通道。先关闭close(naturals)

之后我们在squarer中加入，检测是否当前的接收操作在一个已读完且已关闭的通道上，关闭通道

go func() {
	for {
		x,ok := <-naturals
		if !ok{
			break
		}
		squares <- x*x
	}
	close(squares)
}()

这一段逻辑可以使用等价的range来替换

go func() {
	for x := range naturals
		squares <- x*x
	}
	close(squares)
}()

单向通道类型

只能用于接收的通道<-chan int和只能用于发送的通道chan<- int，用于更清晰的为程序功能进行分块。这样改写上面的程序

func counter(out chan<- int) {
	for x:=0;x<100;x++ {
		out <- x
	}
	close(out)
}
func squarer(out chan<- int,in <-chan int) {
	for v:= range in {
		out <- v*v
	}
	close(out)
}
func printer(in <-chan int) {
	for v:= range in {
		fmt.Println(v)
	}
}

fn main() {
	naturals := make(chan int)
	squares := make(chan int)
	go counter(naturals)
	go squarer(squares,naturals)
	printer(squares)
}	

注意手法：在函数的形参声明中使用单向通道类型，在传入实参时传入正常的通道。

缓冲通道

缓冲通道通过在make时指定缓冲大小创建

ch := make(chan int,3)

缓冲通道有一个队列（就是那个先入先出的数据结构）

• 插入时，在队列的尾部插入一个元素。如果缓存已满，则阻塞进行插入操作的goroutine，直到队列有空出来的空间
• 接收时，拿出队列头的元素。如果队列已空，则阻塞进行接收操作的goroutine，直到队列中再次有东西

使用cap(ch)来查看通道的容量，使用len(ch)来查看通道内元素的数量

一个简单的例子：向三个镜像地址发送请求，接收最快返回的响应

func mirroredQuery() string {
	responses := make(chan string,3)
	go func() {responses <- request("镜像地址1")}()
	go func() {responses <- request("镜像地址2")}()
	go func() {responses <- request("镜像地址3")}()
	return <-reponses

这里使用无缓冲通道就是不正确的，因为两个比较慢的goroutine会因为一直不被接收而被永远的阻塞，是导致“goroutine泄露”的一种情况。

并行循环

这一节以一个例子讲解。
初始任务：给定一个图像名字列表，给每一个图像生成一个缩略图

package thumbnail
func ImageFile(infile string) (string,error) //处理缩略图的功能函数
func makeThumbnails(filenames []string) {
	for _,f := range filenames{
		if_,err := thumbnail.ImageFile(f); err != nil {
			log.Printlin(err)
		}
	}
}

该任务由完全互相独立的子问题构成，这种任务称为“高度并行”。我们尝试给所有子任务都放到一个goroutine上取处理

func makeThumbnails(filenames []string) {
	for _,f := range filenames{
		go thumbnail.ImageFile(f)
	}
}

这样写就大错特错了，这是因为该函数只是迅速的启动了所有goroutine，没等他们执行完毕就直接返回了。解决的方法是，在内层的goroutine使用一个共享的通道来向外层报告任务完成

func makeThumbnails(filenames []string) {
	ch := make(chan bool)
	for _,f := range filenames{
		go func(f string) {
			thumbnail.ImageFile(f)
			ch <- true
		}(f)
	}
	for range filenames {
		<-ch
	}
}

原理是，先开启所有的goroutine进行缩略图的制作，每个缩略图制作完后该goroutine被阻塞，直到我们外层的goroutine逐一接收ch。我们能这么做的原因是我们事先知道有多少goroutine，直接使用range filenames来清空我们的通道
目前为止，这个并发还没有实现返回生成的文件名和可能存在的错误。为了达到这个效果，我们选择使用缓冲通道

func makeThumbnails(filenames []string) (thumbfiles []string,err error) {
	type item struct {
		thumbfile string
		err error
	}
	ch := make(chan item,len(filenames))
	
	for _,f := range filenames{
		go func(f string) {
			var it item
			it.thumbfile,it.err = thumbnail.ImageFile(f)
			ch <- it
		}(f)
	}
	for range filenames {
		it := <-ch
		if it.err != nil {
			return nil,it.err
		}
		thumbfiles = append(thumbiles,it.thumbfile)
	}
	return thumbfiles,nil
}

下面展示如何使用计数器sync.WaitGroup来实现一个新函数。该函数为从传给他的通道中接收到的每个文件生成缩略图。由于这次我们不能提前获知goroutine的个数，我们需要在每一个foroutine启动前增加计数，在每一个goroutine结束时减少计数，直到计数器变为0

func makeThumbnails(filenames <-chan string) int64 {
	sizes := make(chan int64) //文件大小通道
	var wg sync.WaitGroup
	for f := range filenames {
		wg,Add(1)
		go func(f string) {
			defer wg.Done()
			thumb,err := thumbnail.ImageFile(f)
			if err != nil {
				log.Println(err)
				return
			}
			info,_  := os.Stat(thumb)
			size <- info.Size()
		}(f)
	}

	go func() {
		wg.Wait()
		close(sizes)
	}()
	
	var total int64
	for size := range sizes {
		total += size
	}
	return total	                                                                                                                   
}

• wg.Add(1)，增加数量，必须在工作goroutine开始之前执行
• wg.Done()，计数器减少1，使用defer使得在发生错误时计数器也可以正常的递减
• wg.Wait()，一直阻塞所在的goroutine，直到计数器归0

select语句

select可以监听多个 channel 上的数据流动，并在其中任意一个 channel 准备好数据时执行对应的 case 语句。下面是 select 语句的语法：

select {
case <- channel1:
    // 处理 channel1 中的数据
case data := <- channel2:
    // 处理 channel2 中的数据
case channel3 <- data:
    // 向 channel3 中发送数据
default:
    // 当没有任何 channel 准备好数据时执行的代码
}

我们可以使用一个缓冲区大小为1的通道来打印偶数

ch := make(chan int ,1)
for i:=0;i<10;i++ {
	select {
		x := <-ch:
			fmt.Println(x)
		case ch <- i:
	}
}

原理是，一开始缓冲区为空且i=0，此时接受行为会被阻塞，但是传输行为不被阻塞，把0放入缓冲区；之后下一次迭代时，缓冲区已满，接受行为不被阻塞而传输行为被阻塞，执行第一个case语句，输出0；以此类推

需要注意的是

• select 语句只能在函数内部使用
• case 语句中的操作必须是非阻塞的
• 多个case同时满足时，随机选一个执行