Go-并发编程基础（goroutine、channel、select等）

逃离我推掉我的手 2023-01-16 14:24 206阅读 0赞

**目录**

概念

协程 goroutine

goroutine调度-MPG模式

通道Channel

数据结构

声明&初始化

发送与接收

遍历和关闭

单方向的channel

channel中的channel

常见错误

time与select

超时

时间间隔

--------------------

# 概念 #

*  并发：指**宏观**上在**一段时间内**能**同时**运行多个程序，**微观**上**交替**运行。
 *  并行：指**同一时刻**能运行多个指令。
 *  进程：一段程序的执行过程，是系统进行**资源分配**的基本单位，**一个进程至少有一个线程**。
 *  线程：操作系统能够进行**运算调度**的最小单位，它被包含在进程之中。

# 协程 goroutine #

*  有独立的栈空间
 *  共享程序堆空间
 *  调度由用户控制
 *  主线程是一个物理线程,直接作用在cpu上的，是重量级的，非常耗费cpu资源，
 *  协程从主线程开启的，是**轻量级的线程**，是**逻辑态，**对资源消耗相对小。
 *  Golang的协程机制是重要的特点，可以轻松的开启上万个协程。其它编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这里就突显Golang在并发上的优势了

当一个程序启动时，其主函数即在一个单独的goroutine中运行，称之为**main goroutine**。新的goroutine会用**go**语句来创建。在语法上，go语句是一个普通的函数或方法调用前加上关键字go。go语句会使其语句中的函数在一个新创建的goroutine中运行。**而go语句本身会迅速地完成。当主函数返回时，所有的goroutine都会直接打断，程序退出。**

操作已经就绪，对应的goroutine就会重新分配到**逻辑处理器**上来完成操作。**调度器**对可以创建的逻辑处理器的数量没有限制，但语言运行时默认限制每个程序最多创建10000个线程。这个限制值可以通过调用runtime/debug包的SetMaxThreads方法来更改。如果程序试图使用更多的线程，就会崩溃。

## goroutine调度-MPG模式 ##

M(Main Thread):操作系统的主线程(是物理线程)，又称内核线程。

P(Processor):处理器，管理协程，例如协程执行需要的上下文等

G(Goroutine):go协程

举个例子：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_20_color_FFFFFF_t_70_g_se_x_16][]

分成两个部分来看

原来的情况是M主线程正在执行G0协程,另外有三个协程在队列等待如果G0协程阻塞,比如读取文件或者数据库等。

这时就会创建M1主线程(也可能是从已有的线程池中取出M1),并且将等待的3个协程挂到M1下开始执行,M0的主线程下的G0仍然执行文件io的读写。等到G0不阻塞了,M0会被放到空闲的主线程继续执行(从已有的线程池中取),同时G0又会被唤醒。

这样的MPG调度模式,可以既让G0执行,同时也不会让队列的其它协程一直阻塞,仍然可以并发/并行执行。

进行调度的调度器为Seched，它维护有存储空闲的M队列和空闲的P队列，可运行的G队列，自由的G队列以及调度器的一些状态信息等。

package main
    
    import (
    	"fmt"
    	"runtime"
    	"time"
    )
    
    func routinetest(name string){
    	for i:=0;i<3;i++{
    		fmt.Println("routinetest",i,":hello,",name)
    		time.Sleep(100*time.Millisecond)
    	}
    }
    
    func main() {
    	num :=runtime.NumCPU()
    	fmt.Println(num)
    	runtime.GOMAXPROCS(num)
    	//runtime.GOMAXPROCS(1)
    	//--------使用go开启协程----------
    	go routinetest("lady")
    	go routinetest("killer")
    	time.Sleep(time.Second)
    }

可以通过runtime.GOMAXPROCS设置cpu数，这里设置成了8个。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_18_color_FFFFFF_t_70_g_se_x_16][]

# 通道Channel #

相对于sync的低水平同步，使用channel可以实现高水平同步，channel是**先进先出**的。

## 数据结构 ##

Channel 在运行时的内部表示是 [runtime.hchan][]，该结构体中包含了用于保护成员变量的**互斥锁**，从某种程度上说，Channel 是一个用于同步和通信的**有锁队列**，使用互斥锁解决程序中可能存在的线程竞争问题是很常见的，我们能很容易地实现有锁队列。

type hchan struct {
    	qcount   uint
    	dataqsiz uint
    	buf      unsafe.Pointer
    	elemsize uint16
    	closed   uint32
    	elemtype *_type
    	sendx    uint
    	recvx    uint
    	recvq    waitq
    	sendq    waitq
    	lock mutex
    }

[runtime.hchan][] 结构体中的五个字段 `qcount`、`dataqsiz`、`buf`、`sendx`、`recv` 构建底层的循环队列：

*  `qcount` — Channel 中的元素个数；
 *  `dataqsiz` — Channel 中的循环队列的长度；
 *  `buf` — Channel 的缓冲区数据指针；
 *  `sendx` — Channel 的发送操作处理到的位置；
 *  `recvx` — Channel 的接收操作处理到的位置；

除此之外，`elemsize` 和 `elemtype` 分别表示当前 Channel 能够收发的元素类型和大小；`sendq` 和 `recvq` 存储了当前 Channel 由于缓冲区空间不足而阻塞的 Goroutine 列表，这些等待队列使用双向链表 [runtime.waitq][] 表示，链表中所有的元素都是 [runtime.sudog][] 结构：

type waitq struct {
    	first *sudog
    	last  *sudog
    }

[runtime.sudog][] 表示一个在等待列表中的 Goroutine，该结构中存储了两个分别指向前后 [runtime.sudog][] 的指针以构成链表。

## 声明&初始化 ##

初始化需要使用make(t Type, size ...IntegerType) Type，size为缓存大小

>     var b chan int
>     var c = make(chan int)
>     var d = make(chan int,10)

b为nil，c为无缓存channel，d为有缓存channel

## 发送与接收 ##

发送使用channel<-data，接收使用\[var,ok\]:=<-channel，当左侧没有变量接收时会直接丢弃掉数据，ok可以标识channel是否有数据，无数据是，接收变量获取到的是对应类型的零值。

对于nil的channel，发送和接收都会阻塞，所以不make的channel没有用，实际编程中channel应该都初始化

对于无缓存的channel，发送后会阻塞，直至接收

对于有缓存的channel，满了后发送会被阻塞，接收无影响

## 遍历和关闭 ##

关闭后无法写入，只能读取，例如

close(d)

普通for循环

for j := 0;j<len(c); j++{
    		fmt.Println(<-c)
    	}

若取的时候，没有其他goroutine写入的话，会读出一半。例如，刚开始len(c)是10个，当j为5时，len(c)也是5了，就跳出循环了。

for j := 0;len(c)!=0; j++{
    		fmt.Println(<-c)
    	}

上面这种方法可以

for range

**关闭后**可以正常遍历，遍历也是从channel中接收值，大小会变化，例如

for data := range d{
    		fmt.Println(data)
    	}

若不关闭，会一直接收数据，即使当前channel没有数据了，无goroutine写入时会block，若是在main routine中，会导致deadlock错误。

<table style="width:700px;">  channel状态总结  
 <thead> 
  <tr> 
   <th style="width:133px;">动作\状态</th> 
   <th style="width:55px;">nil</th> 
   <th>非空</th> 
   <th>空的</th> 
   <th>满了</th> 
   <th>没满</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="width:133px;">接收</th> 
   <td style="width:55px;"><span style="color:#ffd900;">阻塞</span></td> 
   <td>接收值</td> 
   <td><span style="color:#ffd900;">阻塞</span></td> 
   <td>接收值</td> 
   <td>接收值</td> 
  </tr> 
  <tr> 
   <th style="width:133px;">发送&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</th> 
   <td style="width:55px;"><span style="color:#ffd900;">阻塞</span></td> 
   <td>发送值</td> 
   <td>发送值</td> 
   <td><span style="color:#ffd900;">阻塞</span></td> 
   <td>发送值</td> 
  </tr> 
  <tr> 
   <th style="width:133px;">关闭</th> 
   <td style="width:55px;"><strong>panic</strong></td> 
   <td>关闭成功，读完数据后返回零值</td> 
   <td>关闭成功，返回零值</td> 
   <td>关闭成功，读完数据后返回零值</td> 
   <td>关闭成功，读完数据后返回零值</td> 
  </tr> 
 </tbody> 
</table>

## 单方向的channel ##

只发送chan<-int

只接收

var in =  make(chan <- int)
    var out = make(<-chan int,3)

## channel中的channel ##

package main
    
    import "fmt"
    
    type Request struct{
    	num int
    	result chan int
    }
    
    func result(r Request)  {
    	r.result <- r.num + 1
    }
    
    func main() {
    	r := Request{1,make(chan int)}
    	go result(r)
    	fmt.Println(<-r.result)
    }

## 常见错误 ##

panic: close of nil channel

关闭nil的channel

fatal error: all goroutines are asleep - deadlock!

main routine被永久阻塞，例如，接收一个空的channel，一直没有goroutine向里面放数据

panic: send on closed channel

向关闭的channel中发送数据

# time与select #

select是针对并发特有的控制结构。和switch很像，但每个case不是表达式而是通信，当有多个case可以时，将伪随机选择一个，所以不能依赖select来做顺序通信。

## 超时 ##

> func After(d Duration) <-chan Time

到达一定时间后可以从channel接收数据

package main
    
    import (
    	"fmt"
    	"math/rand"
    	"time"
    )
    
    func main() {
    	timeout := time.After(2*time.Second)
    	c := make(chan int)
    	go func() {
    		for {
    			c<-0
    			time.Sleep(time.Duration(rand.Intn(500))*time.Millisecond)
    		}
    	}()
    	for {
    		select {
    		case <-c:
    			fmt.Println("I'm working...")
    		case <-timeout:
    			fmt.Println("time out")
    			return
    		}
    	}
    }

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_17_color_FFFFFF_t_70_g_se_x_16][]

## 时间间隔 ##

> func Tick(d Duration) <-chan Time

package main
    
    import (
    	"fmt"
    	"math/rand"
    	"time"
    )
    
    func main() {
    	timeout := time.After(3*time.Second)
    	timetrick := time.Tick(time.Second)
    	c := make(chan int)
    	go func() {
    		for {
    			c<-0
    			time.Sleep(time.Duration(rand.Intn(500))*time.Millisecond)
    		}
    	}()
    	for {
    		select {
    		case <-c:
    			fmt.Println("I'm working...")
    		case <-timetrick:
    			fmt.Println("1 second pass")
    		case <-timeout:
    			fmt.Println("3 second")
    			return
    		}
    	}
    }

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_17_color_FFFFFF_t_70_g_se_x_16 1][]

并发的后序内容查看：

[Go-并发模式1(Basic Examples)][Go-_1_Basic Examples]

[Go-并发模式2（Patterns）][Go-_2_Patterns]

更多Go相关内容：[Go-Golang学习总结笔记][Go-Golang]

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/d153a274c8184679b2cf6d28db6bb895.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/a857c62b79404a1196ea3d39ee80054b.png
[runtime.hchan]: https://draveness.me/golang/tree/runtime.hchan
[runtime.waitq]: https://draveness.me/golang/tree/runtime.waitq
[runtime.sudog]: https://draveness.me/golang/tree/runtime.sudog
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_17_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/aa07788b75a54f13bdc28813f7f3f2ac.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbGFkeV9raWxsZXI5_size_17_color_FFFFFF_t_70_g_se_x_16 1]: /images/20221022/f137a4b5c61d43f4a4be97fcc7d75ab6.png
[Go-_1_Basic Examples]: https://blog.csdn.net/lady_killer9/article/details/120144685
[Go-_2_Patterns]: https://blog.csdn.net/lady_killer9/article/details/120145534
[Go-Golang]: https://blog.csdn.net/lady_killer9/article/details/115491317