Go——并发基础

向右看齐 2023-10-09 21:12 96阅读 0赞

### 1、并发和并行 ###

并发和并行是两个不同的概念：

*  并行意味着程序在任意时刻都是同时运行的：
 *  并发意味着程序在单位时间内是同时运行的。

并行就是在任一粒度的时间内都具备同时执行的能力：最简单的并行就是多机，多台机器并行处理；SMP表面上看是并行的，但由于是共享内存，以及线程间的同步等，不可能完全做到并行。

并发是在规定的时间内多个请求都得到执行和处理，强调的是给外界的感觉，实际上内部可能是分时操作的。并发重在避免阻塞，使程序不会因为一个阻塞而停止处理。并发典型的应用场景：分时操作系统就是一种并发设计（忽略多核CPU)。

并行是硬件和操作系统开发者重点考虑的问题，作为应用层的程序员，唯一可以选择的就是充分借助操作系统提供的API和程序语言特性，结合实际需求设计出具有良好并发结构的程序，提升程序的并发处理能力。现代操作系统能够提供的最基础的并发模型就是多线程和多进程；编程语言这一层级可以进一步封装来提升程序的并发处理能力。  
在当前的计算机体系下：并行具有瞬时性，并发具有过程性；并发在于结构，并行在于执行。应用程序具备好的并发结构，操作系统才能更好地利用硬件并行执行，同时避免阻塞等待，合理地进行调度，提升CPU利用率。应用层程序员提升程序并发处理能力的一个重要手段就是为程序设计良好的并发结构。

### 2、goroutine ###

操作系统可以进行线程和进程的调度，本身具备并发处理能力，但进程切换代价还是过于高昂，进程切换需要保存现场，耗费较多的时间。如果应用程序能在用户层再构筑一级调度，将并发的粒度进一步降低，是不是可以更大限度地提升程序运行效率呢？Go语言的并发就是基于这个思想实现的。G0语言在语言层面支持这种并发模式。

Go语言的并发执行体称为goroutine,routine的英文翻译是例程，所以goroutine叫Go例程更合理。Go语言通过go关键字来启动一个goroutine。注意：go关键字后面必须跟一个函数，不能是语句或其他东西，函数的返回值被忽略。

*  通过go+匿名函数形式启动goroutine,代码如下：

package main
    
    import (
    	"runtime"
    	"time"
    )
    
    func main() {
        
    	go func() {
        
    		sum := 0
    		for i := 0; i < 10000; i++ {
        
    			sum += i
    		}
    		println(sum)
    		time.Sleep(1 * time.Second)
    	}()
    
    	//NumGoroutine可以返回当前程序的goroutine数目
    	println("NumGoroutine=", runtime.NumGoroutine())
    
    	//main goroutine故意sleep 5秒，放置其提前对出
    	time.Sleep(5 * time.Second)
    }
    
    //结果是
    NumGoroutine= 2
    49995000

*  通过go+有名函数形式启动goroutine，代码如下：

package main
    
    import (
    	"runtime"
    	"time"
    )
    
    func main() {
        
    	go sum()
    	println("NumGoroutine=", runtime.NumGoroutine())
    	time.Sleep(5 * time.Second)
    }
    
    func sum() {
        
    	sum := 0
    	for i := 0; i < 10000; i++ {
        
    		sum += i
    	}
    	println(sum)
    	time.Sleep(1 * time.Second)
    }
    
    //结果
    NumGoroutine= 2
    49995000

##### goroutine有如下特性 #####

*  go的执行是非阻塞的，不会等待。
 *  go后面的函数的返回值会被忽略。
 *  调度器不能保证多个goroutine的执行次序。
 *  没有父子goroutine的概念，所有的goroutine是平等地被调度和执行的。
 *  Go程序在执行时会单独为main函数创建一个goroutine,遇到其他go关键字时再去创建其他的goroutine.
 *  Go没有暴露goroutine id给用户，所以不能在一个 goroutine里面显式地操作另一个goroutine,不过runtime包提供了一些函数访问和设置goroutine的相关信息。

##### 1. func GOMAXPROCS #####

func GOMAXPROCS(n int)用来设置或查询可以并发执行的goroutine数目，n大于1表示设置GOMAXPROCS值，否则表示查询当前的GOMAXPROCS值。例如：

package main
    
    import "runtime"
    
    func main() {
        
    	//获取当前的GOMAXPROCS值
    	println("GOMAXPROCS=", runtime.GOMAXPROCS(0))//12
    
    	//设置GOMAXPROCS的值为2
    	runtime.GOMAXPROCS(2)
    
    	//获取当前的GOMAXPROCS值
    	println("GOMAXPROCS=", runtime.GOMAXPROCS(0))//2
    }

##### 2. func Goext #####

func Goexit()是结束当前goroutine的运行，Goexit在结束当前goroutine运行之前会调用当前goroutine已经注册的defer。Goexit并不会产生panic，所以该goroutine defer里面的recover调用返回都是nil。

##### 3. func Gosched #####

func Gosched()是放弃当前调度执行机会，将当前goroutine放到队列中等待下次被调度。

### 3、chan ###

chan是Go语言里面的一个关键字，是channel的简写，翻译为中文就是通道。goroutine是Go语言里面的并发执行体，通道是goroutine之间通信和同步的重要组件。Go的哲学是“不要通过共享内存来通信，而是通过通信来共享内存”，通道是Go通过通信来共享内存的载体。

通道是有类型的，可以简单地把它理解为有类型的管道。声明一个简单的通道语句是chan dataType,但是简单声明一个通道变量没有任何意义，a并没有初始化，其值是nil。Go语言提供一个内置函数make来创建通道。例如：

//创建一个无缓冲的通道，通道存放元素的类型为datatype
    make(chan datatype)
    
    //创建一个有10个缓冲的通道，通道存放元素的类型为datatype

通道分为无缓冲的通道和有缓冲的通道，Go提供内置函数len和cap,无缓冲的通道的len和cap都是0,有缓冲的通道的len代表没有被读取的元素数，cap代表整个通道的容量。无缓冲的通道既可以用于通信，也可以用于两个goroutine的同步，有缓冲的通道主要用于通信。

package main
    
    import "runtime"
    
    func main() {
        
    	c := make(chan struct{
        })
    	go func(i chan struct{
        }) {
        
    		sum := 0
    		for i := 0; i < 10000; i++ {
        
    			sum += i
    		}
    		println(sum)
    		//写通道
    		c <- struct{
        }{
        }
    	}(c)
    
    	println("NumGoroutine=", runtime.NumGoroutine())
    
    	//读通道c，通过通道进行同步等待
    	<-c
    }

goroutine运行结束后退出，写到缓冲通道中的数据不会消失，它可以缓冲和适配两个goroutine处理速率不一致的情况，缓冲通道和消息队列类似，有削峰和增大吞吐量的功能。

示例如下：

package main
    
    import "runtime"
    
    func main() {
        
    	c := make(chan struct{
        })
    	ci := make(chan int, 100)
    
    	go func(i chan struct{
        }, j chan int) {
        
    		for i := 0; i < 10; i++ {
        
    			ci <- i
    		}
    		close(ci)
    		//写通道
    		c <- struct{
        }{
        }
    	}(c, ci)
    
    	println("NumGoroutine=", runtime.NumGoroutine())
    
    	//读通道c，通过通道进行同步等待
    	<-c
    
    	//此时ci通道已经关闭，匿名函数启动的goroutine已经退出
    	println("NumGoroutine=", runtime.NumGoroutine())
    
    	//但通道ci还可以继续读取
    	for v := range ci {
        
    		println(v)
    	}
    }
    
    //结果
    NumGoroutine= 2
    NumGoroutine= 1
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

操作不同状态的chan会引发三种行为：

panic:

1.  向已经关闭的通道写数据会导致panic。  
    最佳实践是由写入者关闭通道，能最大程度地避免向已经关闭的通道写数据而导致的panic。
2.  重复关闭的通道会导致panic。

阻塞：

1.  向未初始化的通道写数据或读数据都会导致当前goroutine的永久阻塞。
2.  向缓冲区已满的通道写入数据会导致goroutine阻塞。
3.  通道中没有数据，读取该通道会导致goroutine阻塞。

非阻塞：

1.  读取已经关闭的通道不会引发阻塞，而是立即返回通道元素类型的零值，可以使用comma,ok语法判断通道是否已经关闭。
2.  向有缓冲且没有满的通道读/写不会引发阻塞。

### 4、WaitGroup ###

goroutine和chan,一个用于并发，另一个用于通信。没有缓冲的通道具有同步的功能，除此之外，sync包也提供了多个goroutine同步的机制，主要是通过WaitGroup实现  
的。

主要数据结构和操作如下：

type WaitGroup struct {
        
    	//contains filtered or unexported fields
    }
    
    //添加等待信号
    func (wg *WaitGroup) Add(delta int)
    
    //释放等待信号
    func (wg *WaitGroup) Done()
    
    //等待
    func (wg *WaitGroup) Wait()

WaitGroup用来等待多个goroutine完成，main goroutine调用Add设置需要等待goroutine的数目，每一个goroutine结束时调用Done(),Wait()被main用来等待所有的goroutine完成。

下面的程序演示如何使用sync.WaitGroup完成多个goroutine之间的协同工作。

package main
    
    import (
    	"net/http"
    	"sync"
    )
    
    var wg sync.WaitGroup
    var urls = []string{
        
    	"http://www.baidu.com/",
    	"http://www.sina.com.cn/",
    	"http://www.qq.com/",
    }
    
    func main() {
        
    	for _, url := range urls {
        
    		//每一个URL启动一个goroutine，同时wg加一
    		wg.Add(1)
    
    		go func(url string) {
        
    			//当前goroutine结束后给wg计数减一，wg.Done()等价于wg.add(-1)
    			//defer wg.Add(-1)
    			defer wg.Done()
    
    			//发送HTTP get请求并打印HTTP返回码
    			resp, err := http.Get(url)
    			if err == nil {
        
    				println(resp.Status)
    			}
    		}(url)
    	}
    	//等待所有请求结束
    	wg.Wait()
    }
    
    //结果
    200 OK
    200 OK
    501 Not Implemented

### 5、select ###

select是类UNIX系统提供的一个多路复用系统API，Go语言借用多路复用的概念，提供了select关键字，用于多路监听多个通道。当监听的通道没有状态是可读或可写的，select是阻塞的；只要监听的通道中有一个状态是可读或可写的，则select就不会阻塞，而是进入处理就绪通道的分支流程。如果监听的通道有多个可读可写的状态，则select随机选取一个处理。

示例如下：

package main
    
    func main() {
        
    	ch := make(chan int, 1)
    	go func(chan int) {
        
    		for {
        
    			select {
        
    			//0或1的写入是随机的
    			case ch <- 0:
    			case ch <- 1:
    			}
    		}
    	}(ch)
    	for i := 0; i < 10; i++ {
        
    		println(<-ch)
    	}
    }
    
    //结果
    0
    0
    1
    1
    1
    1
    0
    0
    0
    0

### 6、扇入（Fan in）和扇出（Fan out） ###

编程中经常遇到“扇入和扇出”两个概念，所谓的扇入是指将多路通道聚合到一条通道中处理，Go语言最简单的扇入就是使用select聚合多条通道服务；所谓的扇出是指将一条通道发散到多条通道中处理，在Go语言里面具体实现就是使用go关键字启动多个goroutine并发处理。

中国有句经典的哲学名句叫“分久必合，合久必分”，软件的设计和开发也遵循同样的哲学思想，扇入就是合，扇出就是分。当生产者的速度很慢时，需要使用扇入技术聚合多个生产者满足消费者，比如很耗时的加密/解密服务；当消费者的速度很慢时，需要使用扇出技术，比如Wb服务器并发请求处理。扇入和扇出是Go并发编程中常用的技术。

### 7、通知退出机制 ###

读取已经关闭的通道不会引起阻塞，也不会导致panic,而是立即返回该通道存储类型的零值。关闭select监听的某个通道能使select立即感知这种通知，然后进行相应的处理，这就是所谓的退出通知机制(close channel to broadcast)。

下面通过一个随机数生成器的示例演示退出通知机制，下游的消费者不需要随机数时，显式地通知生产者停止生产:

package main
    
    import (
    	"fmt"
    	"math/rand"
    	"runtime"
    )
    
    func main() {
        
    	done := make(chan struct{
        })
    	ch := GenerateIntA(done)
    
    	fmt.Println(<-ch)
    	fmt.Println(<-ch)
    
    	//发送通知，告诉生产者停止生产
    	close(done)
    
    	fmt.Println(<-ch)
    	fmt.Println(<-ch)
    
    	//次数生产者已经退出
    	fmt.Println("NumGoroutine=", runtime.NumGoroutine())
    }
    
    //GenerateIntA是一个随机数生成器
    func GenerateIntA(done chan struct{
        }) chan int {
        
    	ch := make(chan int)
    	go func() {
        
    	Lable:
    		for {
        
    			select {
        
    			case ch <- rand.Int():
    			//增加一路监听，就是对退出通知信号done的监听
    			case <-done:
    				break Lable
    			}
    		}
    		//收到通知后关闭通道ch
    		close(ch)
    	}()
    	return ch
    }
    
    //结果
    5577006791947779410
    8674665223082153551
    0
    0
    NumGoroutine= 1