【go语言 | 第4篇】goroutine模型和调度策略

协程

传统的时间片轮转对线程的调度，CPU切换会消耗大量成本，甚至在线程数量很多的情况下，CPU切换的时间高于线程的执行时间。

期望提高 CPU 利用率，解决高消耗调度 CPU 以及 高内存占用。

将线程分为内核态和用户态，CPU 本身是无感的，从 CPU 的角度看去，还是认为自己处理的是整个线程（包括内核态和用户态）

通过一个协程调度器，来进行业务调度，处理 CPU 高调度影响：

缺点：因为是轮询，当某个协程阻塞时，会对下一个协程造成影响。

1:1 关系：

M:N 关系：

重心在于优化协程调度器，协程调度器越好，CPU 利用率越高。

golang调度器

1. golang对早期调度器的处理

调度器：

缺点：
1.创建、销毁、调度G都需要每个M获取锁，这就形成了激烈的锁竞争。
2.M转移G会造成延迟和额外的系统负载。
3.系统调用(CPU在M之间的切换）导致频繁的线程阻塞和取消阻塞操作增加了系统开销。

2. GMP

processor处理器：用来处理 goroutine 协程。

每个线程（M）通过一个process调度器（P）来处理协程（G），每个 P 管理一个存储 G 的本地队列，还会有一个额外的全局队列。
系统能够并行的最高的协程数量就是 GOMAXPROCES 的个数。

3. 调度器的设计策略

（1）复用线程

1. work stealing 机制
   
   M1 正在通过 P 正在处理 G1，P的本地队列中还有等待处理的 G。M2 此时是空闲的，希望能利用上 M2，它自身没有任何协程，就会从其他队列中偷取一个 G 过来，进行处理:

2. hand off 机制
   
   M1 线程的 G1 阻塞了，CPU 一直等待，没有任何意义；并且阻塞了队列中的 G2 执行。
   把 M1 和 P 分离，创建一个新的线程来处理 P：
   

（2）利用并行

GOMAXPROCES 限定 P 的个数 = CPU核心数/2

（3）抢占

对于每个 G，CPU 最多等待执行 10ms，时间到了，另外的 G 就会抢占 CPU：

（4）全局 G 队列

M2 此时没有任何队列，会优先从其他队列偷 G；但 M1 队列中也没有 G，就会从全局队列中获取 G：

从全局队列中获取 G 需要进行加解锁，速度会比较慢。

创建 goroutine

1. 创建 goroutine

packagemainimport("fmt""time")funcnewTask(){i:=0for{i++;fmt.Printf("new goroutine: %d\n",i)time.Sleep(1*time.Second)}}// 主 gorutinefuncmain(){// 创建一个 go 程，去执行 newTask()gonewTask()i:=0for{i++fmt.Printf("main goroutine: %d\n",i)time.Sleep(1*time.Second)}}

main退出：

packagemainimport("fmt""time")funcnewTask(){i:=0for{i++;fmt.Printf("new goroutine: %d\n",i)time.Sleep(1*time.Second)}}// 主 gorutinefuncmain(){// 创建一个 go 程，去执行 newTask()gonewTask()fmt.Println("main goroutine")/* i := 0 for { i++ fmt.Printf("main goroutine: %d\n", i) time.Sleep(1 * time.Second) } */}

主 goroutine 中，创建了一个 go 程，让它去执行 newTask() 方法后；会接着继续执行主 goroutine 内的代码，执行到 fmt,Println 最后一行，就直接退出。

2. 退出 goroutine

packagemainimport("fmt""runtime""time")funcmain(){// 用 go 创建承载一个形参为空，返回值为空的函数gofunc(){deferfmt.Println("defer A")func(){deferfmt.Println("defer B")// 退出当前 goroutineruntime.Goexit()fmt.Println("B")}()fmt.Println("A")}()// 死循环for{time.Sleep(1*time.Second)}}