Go语言——goroutine并发模型
参考：
简介
stack
OS线程初始栈为2MB。Go语言中，每个goroutine采用动态扩容方式，初始2KB，按需增长，最大1G。此外GC会收缩栈空间。
BTW，增长扩容都是有代价的，需要copy数据到新的stack，所以初始2KB可能有些性能问题。
更多关于stack的内容，可以参见大佬的文章。聊一聊goroutine stack
管理
用户线程的调度以及生命周期管理都是用户层面，Go语言自己实现的，不借助OS系统调用，减少系统资源消耗。
G-M-P
Go语言采用两级线程模型，即用户线程与内核线程KSE（kernel scheduling entity）是M:N的。最终goroutine还是会交给OS线程执行，但是需要一个中介，提供上下文。这就是G-M-P模型
- G: goroutine, 类似进程控制块，保存栈，状态，id，函数等信息。G只有绑定到P才可以被调度。
- M: machine, OS线程，绑定有效的P之后，进入调度。
- P: 逻辑处理器，保存各种队列G。对于G而言，P就是cpu core。对于M而言，P就是上下文。P的数量由
GOMAXPROCS设置，最大256。 - sched: 调度程序，保存GRQ，midle M空闲队列，pidle P空闲队列以及lock等信息
G-M-P模型
队列
Go调度器有两个不同的运行队列：
- GRQ，全局运行队列，尚未分配给P的G
- LRQ，本地运行队列，每个P都有一个LRQ，用于管理分配给P执行的G
状态
go1.10\src\runtime\runtime2.go
- _Gidle: 分配了G，但是没有初始化
- _Grunnable: 在run queue运行队列中，LRQ或者GRQ
- _Grunning: 正在运行指令，有自己的stack。不在runq运行队列中，分配给M和P
- _Gsyscall: 正在执行syscall，而非用户指令，不在runq，分给M，P给找idle的M
- _Gwaiting: block。不在RQ，但是可能会在channel的wait queue等待队列
- _Gdead: unused。在P的gfree list中，不在runq。idle闲置状态
- _Gcopystack: stack扩容或者gc收缩
上下文切换
Go调度器根据事件进行上下文切换。
- go关键字，创建goroutine
- gc垃圾回收，gc也是goroutine，所以需要时间片
- system call系统调用，block当前G
- sync同步，block当前G
调度
调度的目的就是防止M堵塞，空闲，系统进程切换。
异步调用
Linux可以通过epoll实现网络调用，统称网络轮询器N（Net Poller）。
- G1在M上运行，P的LRQ有其他3个G，N空闲；
- G1进行网络IO，因此被移动到N，M继续从LRQ取其他的G执行。比如G2就被上下文切换到M上；
- G1结束网络请求，收到响应，G1被移回LRQ，等待切换到M执行。
同步调用
文件IO操作
- G1在M1上运行，P的LRQ有其他3个G；
- G1进行同步调用，堵塞M；
- 调度器将M1与P分离，此时M1下只有G1，没有P。
- 将P与空闲M2绑定，并从LRQ选择G2切换
- G1结束堵塞操作，移回LRQ。M1空闲备用。
任务窃取
上面都是防止M堵塞，任务窃取是防止M空闲
- 两个P，P1，P2
- 如果P1的G都执行完了，LRQ空，P1就开始任务窃取。
- 第一种情况，P2 LRQ还有G，则P1从P2窃取了LRQ中一半的G
- 第二种情况，P2也没有LRQ，P1从GRQ窃取。
g0
每个M都有一个特殊的G，g0。用于执行调度，gc，栈管理等任务，所以g0的栈称为调度栈。g0的栈不会自动增长，不会被gc，来自os线程的栈。
code
go1.10\src\runtime\proc.go
new
// The minimum size of stack used by Go code
var _StackMin = 2048
func newproc1(fn *funcval, argp *uint8, narg int32, callerpc uintptr) {
_g_ := getg()
_p_ := _g_.m.p.ptr()
newg := gfget(_p_)
if newg == nil {
newg = malg(_StackMin)
}
newg.startpc = fn.fn
runqput(_p_, newg, true)
if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 && mainStarted {
wakep()
}
}
- 获取当前G
- 获取当前G的P
- 从P的gfree中获取G，避免重新创建，有点池化的意思
- 如果没有可复用的G，就重新创建，参数表示stack大小，起始2KB，支持动态扩容
- 将G入队，放入P的LRQ中；由于有工作窃取机制，其他P可以从这个P窃取G
- 如果runq满了（长度256），就放入GRQ中，在sched中
- 尝试加入额外的P去执行G
start
G没办法自己运行，必须通过M运行
func mstart() {
mstart1(0)
mexit(osStack)
}
func mstart1(dummy int32) {
_g_ := getg()
if _g_ != _g_.m.g0 {
throw("bad runtime·mstart")
}
schedule()
}
M通过通过调度，执行G
schdule
// One round of scheduler: find a runnable goroutine and execute it.
// Never returns.
func schedule() {
_g_ := getg()
var gp *g
gp, inheritTime = runqget(_g_.m.p.ptr())
execute(gp, inheritTime)
}
从M挂载P的runq中找到G，执行G
