Go语言学习 - 调度器和对应的问题

最新推荐文章于 2022-08-17 16:33:59 发布
最新推荐文章于 2022-08-17 16:33:59 发布
阅读量178 收藏
点赞数
分类专栏： Go语言 学习笔记 服务器编程
原文链接：https://www.ilove-map.com/article/detail/5d583c9144e69c2aee4bad11
版权

Go调度器介绍和容易忽视的问题

什么是调度器

为了方便刚接触操作系统和高级语言的同学，先用大白话介绍下什么是调度器。 调度，是将多个程序合理的安排到有限的CPU上来使得每个程序都能够得以执行，实现宏观的并发执行。比如我们的电脑CPU只有四核甚至双核，可是我们却可以在电脑上同时运行几十个程序，这就是操作系统调度器的功劳。但操作系统调度的是进程和线程，线程简单地说就是轻量级的进程，但是每个线程仍需要MB级别的内存，而且如果两个切换的线程在不同的进程中，还需要进程切换，会使CPU在调度这件事上花费大量时间。 为了更合理的利用CPU，Golang通过goroutine原生支持高并发，goroutine是由go调度器在语言层面进行调度，将goroutine安排到线程上，可以更充分地利用CPU。

Golang的调度器

Golang的调度器在runtime中实现，我们每个运行的程序执行前都会运行一个runtime负责调度goroutine，我们写的代码入口要在main包下的main函数中也是因为runtime.main函数会调用main.main。Golang的调度器在2012被重写过一次，现在使用的是新版的G-P-M调度器，但是我们还是先来看下老的G-M调度器，这样才可以更好的体会当前调度器的强大之处。

G-M模型：

M：代表线程，goroutine都是由线程来执行的； Global G Queue：全局goroutine队列，其中G就代表goroutine，所有M都从这个队列中取出goroutine来执行。 这种模型比较简单，但是问题也很明显：
多个M访问一个公共的全局G队列，每次都需要加互斥锁保护，造成激烈的锁竞争和阻塞；
局部性很差，即如果M1上的G1创建了G2，需要将G2交给M2执行，但G1和G2是相关的，最好放在同一个M上执行。
M中有mcache(内存分配状态)，消耗大量内存和较差的局部性。
系统调用syscall会阻塞线程，浪费不能合理的利用CPU。

G-P-M模型

其中G还是代表goroutine，M代表线程，全局队列依然存在；而新增加的P代表逻辑processor，现在G的眼中只有P，在G的眼里P就是它的CPU。并且给每个P新增加了局部队列来保存本P要处理的goroutine。 这个模型的调度方法如下：
每个P有个局部队列，局部队列保存待执行的goroutine
每个P和一个M绑定，M是真正的执行P中goroutine的实体
正常情况下，M从绑定的P中的局部队列获取G来执行
当M绑定的P的的局部队列已经满了之后就会把goroutine放到全局队列
M是复用的，不需要反复销毁和创建，拥有work stealing和hand off策略保证线程的高效利用。
当M绑定的P的局部队列为空时，M会从其他P的局部队列中偷取G来执行，即work stealing；当其他P偷取不到G时，M会从全局队列获取到本地队列来执行G。
当G因系统调用(syscall)阻塞时会阻塞M，此时P会和M解绑即hand off，并寻找新的idle的M，若没有idle的M就会新建一个M。
当G因channel或者network I/O阻塞时，不会阻塞M，M会寻找其他runnable的G；当阻塞的G恢复后会重新进入runnable进入P队列等待执行
mcache(内存分配状态)位于P，所以G可以跨M调度，不再存在跨M调度局部性差的问题
G是抢占调度。不像操作系统按时间片调度线程那样，Go调度器没有时间片概念，G因阻塞和被抢占而暂停，并且G只能在函数调用时有可能被抢占，极端情况下如果G一直做死循环就会霸占一个P和M，Go调度器也无能为力。

Go调度器奇怪的执行顺序

是不是感觉自己对Go调度器工作原理已经有个初步的了解了？下面指出一个坑给你踩一下，小心了！ 请看下面这段代码输出什么：

func main() {

	done := make(chan bool)

	values := []string{"a", "b", "c"}
	for _, v := range values {
		fmt.Println("--->", v)
		go func(u string) {
			fmt.Println(u)
			done <- true
		}(v)
	}

	// wait for all goroutines to complete before exiting
	for _ = range values {
		<-done
	}

}

实际的数据结果是：

---> a
---> b
---> c
c
b
a

Go调度器示例代码可以在
可能你的第一反应是“不应该是输出a,b,c,吗？为什么输出是c,a,b呢？” 这里我们虽然是使用for循环创建了3个goroutine，而且创建顺序是a,b,c，按之前的分析应该是将a,b,c三个goroutine依次放进P的局部队列，然后按照顺序依次执行a,b,c所在的goroutine，为什么每次都是先执行c所在的goroutine呢？这是因为同一逻辑处理器中三个任务被创建后 理论上会按顺序 被放在同一个任务队列，但实际上最后那个任务会被放在专一的next（下一个要被执行的任务的意思）的位置，所以优先级最高，最可能先被执行，所以表现为在同一个goroutine中创建的多个任务中最后创建那个任务最可能先被执行。

这段解释来自参考文章《Goroutine执行顺序讨论》中。

调度器状态的查看方法

GODEBUG这个Go运行时环境变量很是强大，通过给其传入不同的key1=value1,key2=value2… 组合，Go的runtime会输出不同的调试信息，比如在这里我们给GODEBUG传入了”schedtrace=1000″，其含义就是每1000ms，打印输出一次goroutine scheduler的状态。 下面演示使用Golang强大的GODEBUG环境变量可以查看当前程序中Go调度器的状态：

环境为Windows10的Linux子系统(WSL)，WSL搭建和使用的代码在


func main() {
   var wg sync.WaitGroup
   wg.Add(10)
   for i := 0; i < 10; i++ {
   	go work(&wg)
   }
   wg.Wait()
   // Wait to see the global run queue deplete.
   time.Sleep(3 * time.Second)
}
func work(wg *sync.WaitGroup) {

   time.Sleep(time.Second)
   var counter int
   for i := 0; i < 1e10; i++ {
   	counter++
   }
   wg.Done()
}

编译指令：

go build 01_GODEBUG-schedtrace.go
GODEBUG=schedtrace=1000 ./01_GODEBUG-schedtrace

结果：

SCHED 0ms: gomaxprocs=4 idleprocs=1 threads=5 spinningthreads=1 idlethreads=0 runqueue=0 [4 0 4 0]
SCHED 1000ms: gomaxprocs=4 idleprocs=4 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 0]
SCHED 2007ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 3025ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 4033ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 5048ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 6079ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 7081ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 8092ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 0 0 6]
SCHED 9113ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 10129ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 11134ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 12157ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 13170ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 14183ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 15187ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=3 runqueue=0 [0 1 0 1]
SCHED 16187ms: gomaxprocs=4 idleprocs=2 threads=8 spinningthreads=0 idlethreads=5 runqueue=0 [0 0 0 0]
SCHED 17190ms: gomaxprocs=4 idleprocs=2 threads=8 spinningthreads=0 idlethreads=5 runqueue=0 [0 0 0 0]
SCHED 18193ms: gomaxprocs=4 idleprocs=2 threads=8 spinningthreads=0 idlethreads=5 runqueue=0 [0 0 0 0]
SCHED 19196ms: gomaxprocs=4 idleprocs=2 threads=8 spinningthreads=0 idlethreads=5 runqueue=0 [0 0 0 0]
SCHED 20200ms: gomaxprocs=4 idleprocs=4 threads=8 spinningthreads=0 idlethreads=6 runqueue=0 [0 0 0 0]
SCHED 21210ms: gomaxprocs=4 idleprocs=4 threads=8 spinningthreads=0 idlethreads=6 runqueue=0 [0 0 0 0]
SCHED 22219ms: gomaxprocs=4 idleprocs=4 threads=8 spinningthreads=0 idlethreads=6 runqueue=0 [0 0 0 0]

看到怎么多输出不要慌， 了解每个字段的含义就很清晰了：

SCHED 1000ms 自程序运行开始经历的时间
gomaxprocs=4 当前程序使用的逻辑processor，即P，小于等于CPU的核数。
idleprocs=4 空闲的线程数
threads=8 当前程序的总线程数M，包括在执行G的和空闲的
spinningthreads=0 处于自旋状态的线程，即M在绑定的P的局部队列和全局队列都没有G，M没有销毁而是在四处寻觅有没有可以steal的G，这样可以减少线程的大量创建。
idlethreads=3 处于idle空闲状态的线程
runqueue=0 全局队列中G的数目
[0 0 0 6] 本地队列中的每个P的局部队列中G的数目，我的电脑是四核所有有四个P。
上面的输出信息已经足够我们了解我们的程序运行状况，要想看每个goroutine、m和p的详细调度信息，可以在GODEBUG时加入，scheddetail：

GODEBUG=schedtrace=1000,scheddetail=1 ./01_GODEBUG-schedtrace

结果


SCHED 0ms: gomaxprocs=4 idleprocs=4 threads=7 spinningthreads=0 idlethreads=2 runqueue=0 gcwaiting=0 nmidlelocked=0 stopwait=0 sysmonwait=0
 P0: status=0 schedtick=7 syscalltick=1 m=-1 runqsize=0 gfreecnt=0
 P1: status=0 schedtick=2 syscalltick=1 m=-1 runqsize=0 gfreecnt=0
 P2: status=0 schedtick=1 syscalltick=1 m=-1 runqsize=0 gfreecnt=0
 P3: status=0 schedtick=1 syscalltick=1 m=-1 runqsize=0 gfreecnt=0
 M6: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=-1
 M5: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=-1
 M4: p=-1 curg=33 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=-1
 M3: p=-1 curg=49 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=-1
 M2: p=-1 curg=17 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=-1
 M1: p=-1 curg=-1 mallocing=0 throwing=0 preemptoff= locks=1 dying=0 spinning=false blocked=false lockedg=-1
 M0: p=-1 curg=14 mallocing=0 throwing=0 preemptoff= locks=0 dying=0 spinning=false blocked=true lockedg=-1
 G1: status=4(semacquire) m=-1 lockedm=-1
 G2: status=4(force gc (idle)) m=-1 lockedm=-1
 G3: status=4(GC sweep wait) m=-1 lockedm=-1
 G4: status=4(sleep) m=-1 lockedm=-1
 G5: status=4(sleep) m=-1 lockedm=-1
 G6: status=4(sleep) m=-1 lockedm=-1
 G7: status=4(sleep) m=-1 lockedm=-1
 G8: status=4(sleep) m=-1 lockedm=-1
 G9: status=4(sleep) m=-1 lockedm=-1
 G10: status=4(sleep) m=-1 lockedm=-1
 G11: status=4(sleep) m=-1 lockedm=-1
 G12: status=4(sleep) m=-1 lockedm=-1
 G13: status=4(sleep) m=-1 lockedm=-1
 G14: status=3() m=0 lockedm=-1
 G33: status=3() m=4 lockedm=-1
 G17: status=3() m=2 lockedm=-1
 G49: status=3() m=3 lockedm=-1

原文

weixin_44151597
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go——协程调度
qq_52563729的博客
08-02 2142
1
Go 协程（goroutine）调度原理
技术能量站
12-12 3106
Goroutine调度是一个很复杂的机制，尽管Go源码中提供了大量的注释，但对其原理没有一个好的理解的情况下去读源码收获不会很大。下面尝试用简单的语言描述一下Goroutine调度机制，在此基础上再去研读源码效果可能更好一些。
Go 调度器——schedule
追求幸福，探索未知的博客
07-19 1188
Go调度器很轻量也很简单，足以撑起goroutine的调度工作，并且让Go具有了原生并发的能力。Go调度本质是把大量的goroutine分配到少量线程上去执行，并利用多核并行，实现更强大的并发。
Go GPM 调度器介绍
Rojer_Gz的博客
08-17 714
​ Go调度器很轻量也很简单，足以撑起goroutine的调度工作，并且让Go具有了原生（强大）并发的能力。Go调度本质是把大量的goroutine分配到少量线程上去执行，并利用多核并行，实现更强大的并发。...
Go 调度模型（三）
小知识折射大智慧
04-14 209
别抱怨，也别自怜，所有的现状都是你自己选择的 Scheduler Trace GODEBUG 变量可以控制运行时内的调试变量，参数以逗号分隔，格式为：name=val。本文着重点在调度器观察上，将会使用如下两个参数： schedtrace：设置 schedtrace=X 参数可以使运行时在每 X 毫秒发出一行调度器的摘要信息到标准 err 输出中。 scheddetail：设置...
基于Go语言的学习笔记（附代码）
02-08
本学习笔记主要涵盖了Go语言的基础知识，包括类型、表达式、函数、数据结构、方法、接口、并发以及包管理等多个方面，并附带了源码分析和附录中的工具、调试和测试等内容。 一、类型 1. 变量：Go语言中的变量需要...
Go-scheduler-让计划调度很容易
08-13
标题 "Go-scheduler-让计划调度很容易" 指向的是一个使用 Go 语言实现的计划任务调度器，它简化了在 Go 应用程序中添加定时任务的流程。Go 语言，以其高效的并发模型和简洁的语法，常用于构建高性能的服务端应用，而...
学习资料 golang的GMP调度模型
最新发布
11-02
在编程领域，Go语言（Golang）以其独特的并发模型闻名，这一模型主要基于Goroutines和 channels，而GMP调度模型则是理解Go并发性能的关键。本资料包包含了一个关于GMP调度模型的全面学习资源，包括视频教程、笔记和...
go语言接口用法实例分析
09-22
在Go语言中，接口（Interface）是一种非常重要的抽象机制，它允许我们定义一套方法签名，而不必关心具体的实现。这使得代码更具灵活性和可扩展性。下面我们将详细讲解Go语言接口的定义、实现以及如何在实际编程中...
GO语言实战八 并发相关概念
01-20
Go语言的并发特性是其设计的核心之一，它利用了Goroutines和Channels来实现高效的并发执行。Goroutine可以理解为轻量级的线程，它们...学习和掌握Go语言的并发特性对于编写高性能、可扩展的服务器端应用程序至关重要。
GO的调度器
Pain4Dawn的博客
09-10 185
GPM模型 G：Goroutine，创建的协程 P：Processor线程栈，用于存放G的 M：处理器，一个处理器一个线程栈，用于执行程序 抢占调度 Go程序启动时，runtime会去启动一个名为sysmon的m(一般称为监控线程)。sysmon每20us~10ms启动一次。 释放限制超过5分钟的span物理内存 如果超过2分钟没有垃圾回收，强制执行。 将长时间未处理的netpoll结果添加到任务队列 向长时间运行的G任务发出抢占调度 收回因syscall长时间阻塞的ip ...
Go调度器中的三种结构G、P、M
chen
12-25 2169
Go调度器中的三种结构G、P、M 系统线程固定2M，且维护一堆上下文，对需求多变的并发应用并不友好，有可能造成内存浪费或内存不够用。Go将并发的单位下降到线程以下，由其设计的goroutine初始空间非常小，仅2kb，但支持动态扩容到最大1G，这就是go自己的并发单元——goroutine协程。 实际上系统最小的执行单元仍然是线程，go运行时执行的协程也是挂载到某一系统线程之上的，这种协...
一文彻底弄懂go中的调度GMP
jigetage的专栏
12-02 5763
一文彻底弄懂go中的调度GMP 先说，协程的本质是用户态的线程，用户对其有控制权限，内存占用少，切换代价低。 再来解释一下MPG是什么意思。 M代表内核线程，所有的G都要放在M上才能运行。 P代表控制器，调度G到M上，其维护了一个队列，存储了所有需要它来调度的G。 G代表一个go routine单元。 补充几点常见的调度策略： 1，如果某个M陷入阻塞呢？ 当一个OS线程...
golang（Go语言）调度（二）:goroutine 调度器
weixin_42117918的博客
08-30 265
参阅前期文章：https://blog.csdn.net/weixin_42117918/article/details/83186673 https://blog.csdn.net/weixin_42117918/article/details/83186736 介绍 上一篇文章我对操作系统级别的调度进行了讲解，这对理解 Go 语言的调度...
[翻译]Go语言调度器
Eric ' s Code Blocks
07-08 1886
##译序 本文翻译 Daniel Morsing 的博文 The Go scheduler，个人觉得这篇文章把Go Routine和调度器的知识讲的浅显易懂，作为一篇介绍性的文章，很不错。
理解golang调度之二 ：Go调度器
Shanks
03-15 483
以下内容转载自https://juejin.cn/post/6844903846825705485https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part2.html 前言 这一部分有三篇文章，主要是讲解go调度器的一些内容 三篇文章分别是: 理解golang调度之一 ：操作系统调度 理解golang调度之二 ：Go调度器 理解golang调度之三：并发 简介 第一篇文章解释了关于操作系统层级的调度，这对于理解Go的调度是很重..
【我的架构师之路】- golang源码分析之协程调度器底层实现( G、M、P)
qq_25870633的博客
10-30 5775
本人的源码是基于go 1.9.7 版本的哦！ 紧接着之前写的 【我的区块链之路】- golang源码分析之select的底层实现 和 【我的区块链之路】- golang源码分析之channel的底层实现 我们这一次需要对go的调度器做一番剖析。 go的调度器只要实现在 runtime 包中，路径为： ./src/runtime/proc.go 文件中。 我们都知道go的强大是因为可以起很多 ...
go语言的goroutine调度机制
DO it
10-09 1962
go语言的goroutine调度机制
Go语言并发与GC详解：Goroutine、Channel与调度器原理
Go语言的轻量级Goroutine设计以及智能的调度器，解决了这些问题，使得Go在现代高性能并发编程中脱颖而出。 总结来说，这篇文章将带你了解Go语言并发编程的基础构造，如Goroutine和Channels，以及如何通过各种并发...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值