Golang---GMP调度策略

摘要：Go 能很好的在用户空间支持并发模型，这也是 Go 如此火热的原因，那今天我们来学习 Go 的调度机制。

数据结构

G 结构体

  G 是 goroutine 的缩写，相当于操作系统中的进程控制块，在这里就是 goroutine 的控制结构，是对 goroutine 的抽象，下面是 G 的结构(只列出了部分与调度有关的)：

//用于保存上下文的 gobuf 结构体
type gobuf struct {
    sp   uintptr  //栈指针，上下文中的 sp 指针
    pc   uintptr  //程序计数器，上下文中的 pc 指针
    g    guintptr //指向当前 g  的指针
    ...
}
//用于表示一个等待链表上的 goroutine
type sudog struct {
    g *g  //阻塞列表上的 G

    next *sudog  //双向链表后指针
    prev *sudog  //双向链表前指针
    elem unsafe.Pointer //该 goroutine 的数据指针

    c        *hchan
    ...
}

下面是 G 结构体：

type g struct {
    stack       stack           // offset known to runtime/cgo

    m            *m            // current m; offset known to arm liblink
    sched        gobuf         //进程切换时，利用 sched 来保存上下文
    param        unsafe.Pointer // 用于传递参数，睡眠时其它 goroutine 设置 param, 唤醒时此 goroutine 可以获取到
    goid         int64          //goroutine 的 ID号

    lockedm        muintptr  //G 被锁定只能在这个 m 上运行
    gopc           uintptr   //创建这个goroutine 的go 表达式的 pc
    waiting        *sudog    //这个 g 当前正在阻塞的 sudog 结构体
}

M 结构体

  M 是 machine 的缩写，是对机器的抽象，每个 m 都是对应到一条操作系统的物理线程。M 必须关联了 P 才可以执行 Go 代码，但是当它处理阻塞或者系统调用中时，可以不需要关联 P。

type m struct {
    g0      *g     // 带有调度栈的 goroutine(默认开启一个进程的时候会开启一个线程，又称主线程(g0))

    mstartfn      func()   //执行函数体的
    curg          *g       //当前运行的 goroutine
    p             puintptr //为了执行 Go 代码而获取的 p(如果不需要执行 Go 代码（syscall...），可为 nil)
    id            int64    //M 的 ID
    locks         int32
    park          note
    alllink       *m   //用于链接 allm(一个全局变量)
    schedlink     muintptr
    lockedg       guintptr  //某些情况下，goroutine 锁定到当前 m, 而不会到切换到其它 m 中去
    createstack   [32]uintptr // stack that created this thread.

    nextwaitm     muintptr    //期望获取锁的下一个 m

    syscall   libcall        //存储系统调用的参数
}

P 结构体

  P 是 Processor 的缩写。结构体 P 的加入是为了提高 Go 程序的并发度。一共有 GOMAXPROCS(一般为 CPU 的核数) 个 P, 所有的 P 被组织成一个数组(allp), 在 P 上实现了工作流窃取的调度器。

type p struct {
    id          int32
    status      uint32 //P 状态 pidle/prunning/...
    link        puintptr
    schedtick   uint32     // 每次执行 goroutine 调度 +1
    syscalltick uint32     // 每次执行系统调用 +1
    sysmontick  sysmontick // last tick observed by sysmon
    m           muintptr   // 链接到它的 m (nil if idle)
    mcache      *mcache
    pcache      pageCache

    // Queue of runnable goroutines. Accessed without lock.
    // P 执行 Go 代码时，优先从自己这个局部队列中取，这时可以不用加锁，提高了并发度
    // 如果发现这个队列是空，则去其它 P 的队列中拿一半过来，实现工作流窃取的调度，这种情况需要给调度器加锁
    runqhead uint32  //本地 G 队列头
    runqtail uint32  //本地 G 队列尾
    runq     [256]guintptr  //本地 G 队列
    runnext guintptr  //下一个准备好运行的 goroutine

    sudogcache []*sudog
    sudogbuf   [128]*sudog
    ...
}

Schedt 结构体

type schedt struct {
    lock mutex  //获取调度器的锁，是全局性的锁（比如从全局队列获取 G, 此时必须要加锁）
    
    midle        muintptr // 当前闲置的 m
    nmidle       int32    // 闲置的 m 的个数
    nmidlelocked int32    // 被锁的闲置的 m 的数量
    mnext        int64    // 下一个 M 的 ID
    maxmcount    int32    // 最大允许的 M 的数量
    nmsys        int32    // 系统中除了死锁剩余的 M 的数量
    nmfreed      int64    // 将要释放的 m 的数量

    ngsys uint32          // 系统中的 goroutine 的数量

    pidle      puintptr   // 闲置的 P
    npidle     uint32     // 闲置的 P 的数量
    nmspinning uint32     // 自旋状态的 M 的个数

    // Global runnable queue.
    runq     gQueue      // 全局的 goroutine 队列
    runqsize int32       // 当前队列大小
}

调度策略

  Go 进行并发的基本流程图：

我们通过对调度源码进行分析，来定位上图中的 6 个步骤，看下具体体现：

  程序入口

// from asm_amd64.s
        CALL    runtime·args(SB)    //处理参数
    CALL    runtime·osinit(SB)  //获取 cpu 核数
    CALL    runtime·schedinit(SB)  //调度器的初始化

    // create a new goroutine to start program
    MOVQ    $runtime·mainPC(SB), AX        // entry
    PUSHQ    AX
    PUSHQ    $0            // arg size
    CALL    runtime·newproc(SB)  //创建一个 main goroutine
    POPQ    AX
    POPQ    AX

    // start this M
    CALL    runtime·mstart(SB)  //启动这个 main goroutine 调度系统

    CALL    runtime·abort(SB)    // mstart should never return
    RET

  调度入口

func mstart() {
    _g_ := getg() //获取当前执行的 goroutine
    mstart1()     //主要调度在 mstart1() 中
}

func mstart1() {
    _g_ := getg()  //只有声明，没有函数实体，被编译器写入，目前只有通过注释来知道该函数的作用

    if _g_ != _g_.m.g0 {
        throw("bad runtime·mstart")
    }
    //...

    if fn := _g_.m.mstartfn; fn != nil {  //此处可以看到 M 中的 mstartfn 域为要执行的函数实体
        fn()
    }

    if _g_.m != &m0 {
        acquirep(_g_.m.nextp.ptr())
        _g_.m.nextp = 0
    }
    schedule()  //进行调度，是一个不会结束的函数
}

  调度过程

// One round of scheduler: find a runnable goroutine and execute it.
// Never returns.
func schedule() {
    _g_ := getg()

top:
    //...
    if gp == nil {
        // Check the global runnable queue once in a while to ensure fairness.
        // Otherwise two goroutines can completely occupy the local runqueue
        // by constantly respawning each other.
        if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {  //每61次调度检查一下全局队列，从全局队列中取 G
            lock(&sched.lock)
            gp = globrunqget(_g_.m.p.ptr(), 1)
            unlock(&sched.lock)
        }
    }
    if gp == nil {    // 从本地队列中取 G, 优先级最高
        gp, inheritTime = runqget(_g_.m.p.ptr())
        // We can see gp != nil here even if the M is spinning,
        // if checkTimers added a local goroutine via goready.
    }
    if gp == nil {   // 从别的地方去获取可运行的 G，阻塞操作，直到找到可运行的 G
        gp, inheritTime = findrunnable() // blocks until work is available
    }

    // This thread is going to run a goroutine and is not spinning anymore,
    // so if it was marked as spinning we need to reset it now and potentially
    // start a new spinning M.
    if _g_.m.spinning {  //如果当前 M 是自旋状态，我们需要重置它，或者开启一个新的 M
        resetspinning()
    }

    execute(gp, inheritTime)  //开始执行 G
}

  寻找可运行G 的过程

// Finds a runnable goroutine to execute.
// Tries to steal from other P's, get g from local or global queue, poll network.
func findrunnable() (gp *g, inheritTime bool) {
    _g_ := getg()

top:
    // local runq
    if gp, inheritTime := runqget(_p_); gp != nil { //从本地队列中获取G
        return gp, inheritTime
    }

    // global runq
    if sched.runqsize != 0 { //从全局队列中获取G
        lock(&sched.lock)
        gp := globrunqget(_p_, 0)
        unlock(&sched.lock)
        if gp != nil {
            return gp, false
        }
    }

    // 从 网络I/O 中获取 G
    if netpollinited() && atomic.Load(&netpollWaiters) > 0 && atomic.Load64(&sched.lastpoll) != 0 {
        if list := netpoll(0); !list.empty() { // non-blocking
            gp := list.pop()
            injectglist(&list)
            casgstatus(gp, _Gwaiting, _Grunnable)
            if trace.enabled {
                traceGoUnpark(gp, 0)
            }
            return gp, false
        }
    }

    // Steal work from other P's.
    procs := uint32(gomaxprocs)
    ranTimer := false
    for i := 0; i < 4; i++ {
        for enum := stealOrder.start(fastrand()); !enum.done(); enum.next() {
            if sched.gcwaiting != 0 {
                goto top
            }
            stealRunNextG := i > 2      // first look for ready queues with more than 1 g
            p2 := allp[enum.position()] //从全局变量 allp 中随机获取一个 P
            // 从 p2 中偷取一半的 G,返回其中一个G
            if gp := runqsteal(_p_, p2, stealRunNextG); gp != nil {
                return gp, false
            }
        }
    }
}

  执行 G 过程

// Schedules gp to run on the current M.
func execute(gp *g, inheritTime bool) {
    _g_ := getg()

    // Assign gp.m before entering _Grunning so running Gs have an
    // M.
    _g_.m.curg = gp
    gp.m = _g_.m  //绑定 M 准备运行
    casgstatus(gp, _Grunnable, _Grunning)  //修改 G 状态为 Grunning
    // 给 G 一些变量赋值
    gp.waitsince = 0
    gp.preempt = false
    gp.stackguard0 = gp.stack.lo + _StackGuard

    gogo(&gp.sched)  // 真正执行调用的函数，sched 保存了上下文，只需要传递这个就可以执行了
}

//gogo 函数用汇编实现,主要是 从 g0 stack 切换到 g stack, JMP 到任务函数执行
//from asm_amd64.s
// func gogo(buf *gobuf)
// restore state from Gobuf; longjmp
TEXT runtime·gogo(SB), NOSPLIT, $16-8
MOVQ    buf+0(FP), BX        // gobuf
MOVQ    gobuf_g(BX), DX
MOVQ    0(DX), CX        // make sure g != nil
get_tls(CX)
MOVQ    DX, g(CX)
MOVQ    gobuf_sp(BX), SP    // restore SP
MOVQ    gobuf_ret(BX), AX
MOVQ    gobuf_ctxt(BX), DX
MOVQ    gobuf_bp(BX), BP
MOVQ    $0, gobuf_sp(BX)    // clear to help garbage collector
MOVQ    $0, gobuf_ret(BX)
MOVQ    $0, gobuf_ctxt(BX)
MOVQ    $0, gobuf_bp(BX)
MOVQ    gobuf_pc(BX), BX
JMP    BX  // longjmp 到任务函数执行

  退出过程

// Finishes execution of the current goroutine.
// 切换到 g0 执行退出操作
func goexit1() {
    //...
    mcall(goexit0)
}

// goexit continuation on g0.
func goexit0(gp *g) {
    _g_ := getg()

    casgstatus(gp, _Grunning, _Gdead)  // 修改 G 状态为 Gdead
    if isSystemGoroutine(gp, false) {
        atomic.Xadd(&sched.ngsys, -1)
    }
    // 重置 G 的一些域
    gp.m = nil
    locked := gp.lockedm != 0
    gp.lockedm = 0
    _g_.m.lockedg = 0
    gp.preemptStop = false
    gp.paniconfault = false
    gp._defer = nil // should be true already but just in case.
    gp._panic = nil // non-nil for Goexit during panic. points at stack-allocated data.
    gp.writebuf = nil
    gp.waitreason = 0
    gp.param = nil
    gp.labels = nil
    gp.timer = nil

    dropg()  //与 M 解绑

    if GOARCH == "wasm" { // no threads yet on wasm
        gfput(_g_.m.p.ptr(), gp)
        schedule() // never returns
    }

    if _g_.m.lockedInt != 0 {
        print("invalid m->lockedInt = ", _g_.m.lockedInt, "\n")
        throw("internal lockOSThread error")
    }
    gfput(_g_.m.p.ptr(), gp)  // 将 G 放入本地 freelist, 如果太长，就放入全局 freelist

    schedule()  //继续进行调度
}

  小结

  通过上面的过程分析，可以知道 schedule() 是一个不会结束的函数，循环的过程是：schedule() 找到可运行的 G ------>  execute() 执行------>goexit() 退出------>schedule() 的循环过程，和上图中的过程一致。

源码分析

  对 M 进行分析

//from go/src/runtime/proc.go
func newm(fn func(), _p_ *p) {
    mp := allocm(_p_, fn)
    mp.nextp.set(_p_)
    mp.sigmask = initSigmask
    ...
    newm1(mp)  // 调用 newm1() 创建 M
}

func newm1(mp *m) {
    ...
    execLock.rlock() // Prevent process clone.
    newosproc(mp)    // 创建一个系统线程，所以我们可以把 M 看作系统线程
    execLock.runlock()
}

  M 的状态转换：

  对 P 进行分析

func procresize(nprocs int32) *p {
    // Grow allp if necessary.
    if nprocs > int32(len(allp)) {
        // Synchronize with retake, which could be running
        // concurrently since it doesn't run on a P.
        lock(&allpLock)
        if nprocs <= int32(cap(allp)) {
            allp = allp[:nprocs]
        } else {
            nallp := make([]*p, nprocs)  //remark1: 创建 nprocs 个 p
            // Copy everything up to allp's cap so we
            // never lose old allocated Ps.
            copy(nallp, allp[:cap(allp)])
            allp = nallp
        }
        unlock(&allpLock)
    }

    // initialize new P's  //remark2: 对所有 P 进行初始化
    for i := old; i < nprocs; i++ {
        pp := allp[i]
        if pp == nil {
            pp = new(p)
        }
        pp.init(i)
        atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
    }
    //...
    var runnablePs *p
    for i := nprocs - 1; i >= 0; i-- {
        p := allp[i]
        if _g_.m.p.ptr() == p {
            continue
        }
        p.status = _Pidle   //把当前 P 置 pidle 状态
        if runqempty(p) {
            pidleput(p)     //放入 schdet 的 pidle 空闲链表中
        } else {
            p.m.set(mget())  //如果有可运行的 P，得到 M 进行绑定, 放入可运行链表
            p.link.set(runnablePs)
            runnablePs = p
        }
    }
    return runnablePs
}

  P 的状态转换：

  对 G 进行分析

   首先我们知道：执行 go func() ，编译器会调用 newproc() 创建一个新 goroutine, 我们看一下具体步骤：

func newproc(siz int32, fn *funcval) {
    argp := add(unsafe.Pointer(&fn), sys.PtrSize)
    gp := getg()  //remark1: 获取当前的 g
    pc := getcallerpc()
    systemstack(func() {
        newg := newproc1(fn, argp, siz, gp, pc)  // 调用 newproc1 进行生成 g

        _p_ := getg().m.p.ptr()
        runqput(_p_, newg, true)  //将 G 放入 P 所在的 M 的本地队列中(也可能是全局队列)

        if mainStarted {
            wakep()
        }
    })
}

//go:systemstack
func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
    _g_ := getg()  //获取当前运行的 goroutine, 当前 G 生成下个 G(继生代)

    siz := narg
    siz = (siz + 7) &^ 7

    if siz >= _StackMin-4*sys.RegSize-sys.RegSize {  //检查入参大小
        throw("newproc: function arguments too large for new goroutine")
    }

    _p_ := _g_.m.p.ptr()
    newg := gfget(_p_)  //尝试从 p 的 freelist 中获取一个 G
    if newg == nil {
        newg = malg(_StackMin)  //如果获取不到，新建一个
        casgstatus(newg, _Gidle, _Gdead)  //置状态为 Gdead
        allgadd(newg) // 将新生成的 G 放入 allg
    }
    //...
    // 对 newG 进行初始化
    newg.sched.sp = sp
    newg.stktopsp = sp
    newg.sched.pc = funcPC(goexit) + sys.PCQuantum //保存 goexit 的地址到 pc,执行完成 fn 之后，可以直接跳到 goexit 函数执行
    newg.sched.g = guintptr(unsafe.Pointer(newg))
    gostartcallfn(&newg.sched, fn)  //设置函数实体
    newg.gopc = callerpc
    newg.ancestors = saveAncestors(callergp)
    newg.startpc = fn.fn
    
    casgstatus(newg, _Gdead, _Grunnable)  //更改 G 状态从 Gdead 到 Grunnable
    //...
    newg.goid = int64(_p_.goidcache)     //自增 ID

    return newg
}

  G 的状态转换：

Go为何快？

Go 非常轻量

    Go 非常轻量，主要体现在如下两个方面：

   1：上下文切换代价小。Goroutine  可以理解为用户空间的调度，用 sched 保存 Goroutine 的 上下文状态；而对比 OS 线程的上下文切换则需要涉及模式切换(从用户态到内核态) 更轻量；

    2：内存占用少。线程栈空间通常是 2M, Goroutine 栈空间最小 2K; Golang 程序中可以轻松支持 10W 级别的 Goroutine 运行，而线程数量达到 1K 时， 内存占用就已经达到 2G。

充分利用线程的计算资源

     1：任务窃取。由于现实情况是有的 Goroutine 运行的快，有的满，那么势必肯定会带来的问题就是，忙的忙死，闲的闲死，为调高整体处理效率，当每个 P 之间的 G 任务不均衡时，调度器允许从 GRQ, 或者其它 P 的 LRQ 中获取 G 运行。

    2：减少阻塞。如果正在执行的 Goroutine 阻塞了线程 M 怎么办？P 上的 LRQ 中的 Goroutine 会获取不到调度么？

    在 Go 里面阻塞主要分为以下四种场景：

    A: 由于原子、互斥操作或通道操作导致 Goroutine 阻塞。调度器将把当前阻塞的 Goroutine 切换出去，重新调度 LRQ 上的其它 Goroutine;

    B：由于网络请求和 I/O 操作导致 Goroutine 阻塞。Go 程序提供了网络轮询器(NetPoller) 来处理网络请求和 I/O 操作的问题，其后台通过 kqueue(MacOS), epoll(Linux) 或 iocp(Windows) 来实现多路复用。

    C: 当调用一些系统方法的时候，如果系统方法调用的时候发生阻塞，这种情况下，NetPoller 将无法使用，进行系统调用的 Goroutine 将阻塞当前 M。调度器(Sched)将会介入， 分离 M 和 P, 同时也将 G 带走（G, M 在一起）， 然后调度器引入新的 M1 来服务 P, 此时，可以从 LRQ 中选择另外的 G1 并在 M1 上进行上下文切换。

    D: 如果在 Goroutine 去执行一个 sleep 操作， 导致 M 被阻塞了。Go 程序后台有一个监控线程 sysmon, 它监控哪些长时间运行的 G任务，然后设置可以强占的标识符，别的 Goroutine 就可以抢先进来执行。

总结

   runtime 准备好 G, M, P, 然后 M 绑定 P, M 从各种队列中获取 G, 切换到 G 的执行栈上并执行 G 上的任务函数，调用 goexit 做清理工作并回到 M, 如此反复。

参考文献

https://cloud.tencent.com/developer/article/1069239

[1] goroutine 的调度 【Go 夜读】

[2] Go1.5 源码剖析.pdf   雨痕