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

文章目录

协程
golang调度器
- [1. golang对早期调度器的处理](#1. golang对早期调度器的处理)
- [2. GMP](#2. GMP)
- [3. 调度器的设计策略](#3. 调度器的设计策略)
- - （1）复用线程
  - （2）利用并行
  - （3）抢占
  - [（4）全局 G 队列](#（4）全局 G 队列)
[创建 goroutine](#创建 goroutine)
- [1. 创建 goroutine](#1. 创建 goroutine)
- [2. 退出 goroutine](#2. 退出 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）复用线程

work stealing 机制

M1 正在通过 P 正在处理 G1，P的本地队列中还有等待处理的 G。M2 此时是空闲的，希望能利用上 M2，它自身没有任何协程，就会从其他队列中偷取一个 G 过来，进行处理:
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

go 复制代码

package main

import (
	"fmt"
	"time"
)

func newTask() {
	i := 0
	
	for {
		i++;
		fmt.Printf("new goroutine: %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

// 主 gorutine
func main() {
	// 创建一个 go 程，去执行 newTask()
	go newTask()

	i := 0
	for {
		i++
		fmt.Printf("main goroutine: %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

main退出：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func newTask() {
	i := 0
	
	for {
		i++;
		fmt.Printf("new goroutine: %d\n", i)
		time.Sleep(1 * time.Second)
	}
}

// 主 gorutine
func main() {
	// 创建一个 go 程，去执行 newTask()
	go newTask()

	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

go 复制代码

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	// 用 go 创建承载一个形参为空，返回值为空的函数
	go func() {
		defer fmt.Println("defer A")

		func() {
			defer fmt.Println("defer B")
			// 退出当前 goroutine
			runtime.Goexit()
			fmt.Println("B")
		}()

		fmt.Println("A")
	}()

	// 死循环
	for {
		time.Sleep(1 * time.Second)
	}
}

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	// 用 go 创建承载一个形参为 int，返回值为 bool 的函数
	go func(a int, b int) bool {
		fmt.Println("a = ", a, "  b = ", b)

		return true;
	}(10, 20)

	time.Sleep(1 * time.Second)
	
}

注意：不能直接接收 go func(a int, b int) bool 的返回值，因为这个goroutine 与主goroutine 都是并行的。