func mstart() {_g_ := getg() //_g_ = g0//对于启动过程来说，g0的stack.lo早已完成初始化，所以onStack = falseosStack := _g_.stack.lo == 0if osStack {// Initialize stack bounds from system stack.// Cgo may have left stack size in stack.hi.// minit may update the stack bounds.size := _g_.stack.hiif size == 0 {size = 8192 * sys.StackGuardMultiplier}_g_.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))_g_.stack.lo = _g_.stack.hi - size + 1024}// Initialize stack guards so that we can start calling// both Go and C functions with stack growth prologues._g_.stackguard0 = _g_.stack.lo + _StackGuard_g_.stackguard1 = _g_.stackguard0mstart1()// Exit this thread.if GOOS == "windows" || GOOS == "solaris" || GOOS == "plan9" || GOOS == "darwin" || GOOS == "aix" {// Window, Solaris, Darwin, AIX and Plan 9 always system-allocate// the stack, but put it in _g_.stack before mstart,// so the logic above hasn't set osStack yet.osStack = true}mexit(osStack)
}

func mstart1() {_g_ := getg()  //启动过程时 _g_ = m0的g0if _g_ != _g_.m.g0 {throw("bad runtime·mstart")}// Record the caller for use as the top of stack in mcall and// for terminating the thread.// We're never coming back to mstart1 after we call schedule,// so other calls can reuse the current frame.//getcallerpc()获取mstart1执行完的返回地址//getcallersp()获取调用mstart1时的栈顶地址save(getcallerpc(), getcallersp())asminit()  //在AMD64 Linux平台中，这个函数什么也没做，是个空函数minit()    //与信号相关的初始化，目前不需要关心// Install signal handlers; after minit so that minit can// prepare the thread to be able to handle the signals.if _g_.m == &m0 { //启动时_g_.m是m0，所以会执行下面的mstartm0函数mstartm0() //也是信号相关的初始化，现在我们不关注}if fn := _g_.m.mstartfn; fn != nil { //初始化过程中fn == nilfn()}if _g_.m != &m0 {// m0已经绑定了allp[0]，不是m0的话还没有p，所以需要获取一个pacquirep(_g_.m.nextp.ptr())_g_.m.nextp = 0}//schedule函数永远不会返回schedule()
}

// save updates getg().sched to refer to pc and sp so that a following
// gogo will restore pc and sp.
//
// save must not have write barriers because invoking a write barrier
// can clobber getg().sched.
//
//go:nosplit
//go:nowritebarrierrec
func save(pc, sp uintptr) {_g_ := getg()_g_.sched.pc = pc //再次运行时的指令地址_g_.sched.sp = sp //再次运行时到栈顶_g_.sched.lr = 0_g_.sched.ret = 0_g_.sched.g = guintptr(unsafe.Pointer(_g_))// We need to ensure ctxt is zero, but can't have a write// barrier here. However, it should always already be zero.// Assert that.if _g_.sched.ctxt != nil {badctxt()}
}

// One round of scheduler: find a runnable goroutine and execute it.
// Never returns.
func schedule() {_g_ := getg()  //_g_ = 每个工作线程m对应的g0，初始化时是m0的g0//......var gp *g//......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.//为了保证调度的公平性，每进行61次调度就需要优先从全局运行队列中获取goroutine，//因为如果只调度本地队列中的g，那么全局运行队列中的goroutine将得不到运行if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {lock(&sched.lock) //所有工作线程都能访问全局运行队列，所以需要加锁gp = globrunqget(_g_.m.p.ptr(), 1) //从全局运行队列中获取1个goroutineunlock(&sched.lock)}}if gp == nil {//从与m关联的p的本地运行队列中获取goroutinegp, inheritTime = runqget(_g_.m.p.ptr())if gp != nil && _g_.m.spinning {throw("schedule: spinning with local work")}}if gp == nil {//如果从本地运行队列和全局运行队列都没有找到需要运行的goroutine，//则调用findrunnable函数从其它工作线程的运行队列中偷取，如果偷取不到，则当前工作线程进入睡眠，//直到获取到需要运行的goroutine之后findrunnable函数才会返回。gp, inheritTime = findrunnable() // blocks until work is available}//跟启动无关的代码.....//当前运行的是runtime的代码，函数调用栈使用的是g0的栈空间//调用execte切换到gp的代码和栈空间去运行execute(gp, inheritTime)
}

// Schedules gp to run on the current M.
// If inheritTime is true, gp inherits the remaining time in the
// current time slice. Otherwise, it starts a new time slice.
// Never returns.
//
// Write barriers are allowed because this is called immediately after
// acquiring a P in several places.
//
//go:yeswritebarrierrec
func execute(gp *g, inheritTime bool) {_g_ := getg() //g0//设置待运行g的状态为_Grunningcasgstatus(gp, _Grunnable, _Grunning)//......//把g和m关联起来_g_.m.curg = gp gp.m = _g_.m//......//gogo完成从g0到gp真正的切换gogo(&gp.sched)
}

# func gogo(buf *gobuf)
# restore state from Gobuf; longjmp
TEXT runtime·gogo(SB), NOSPLIT, $16-8#buf = &gp.schedMOVQ    buf+0(FP), BX        # BX = buf#gobuf->g --> dx registerMOVQ    gobuf_g(BX), DX  # DX = gp.sched.g#下面这行代码没有实质作用，检查gp.sched.g是否是nil，如果是nil进程会crash死掉MOVQ    0(DX), CX        # make sure g != nilget_tls(CX) #把要运行的g的指针放入线程本地存储，这样后面的代码就可以通过线程本地存储#获取到当前正在执行的goroutine的g结构体对象，从而找到与之关联的m和pMOVQ    DX, g(CX)#把CPU的SP寄存器设置为sched.sp，完成了栈的切换MOVQ    gobuf_sp(BX), SP    # restore SP#下面三条同样是恢复调度上下文到CPU相关寄存器MOVQ    gobuf_ret(BX), AXMOVQ    gobuf_ctxt(BX), DXMOVQ    gobuf_bp(BX), BP#清空sched的值，因为我们已把相关值放入CPU对应的寄存器了，不再需要，这样做可以少gc的工作量MOVQ    $0, gobuf_sp(BX)    # clear to help garbage collectorMOVQ    $0, gobuf_ret(BX)MOVQ    $0, gobuf_ctxt(BX)MOVQ    $0, gobuf_bp(BX)#把sched.pc值放入BX寄存器MOVQ    gobuf_pc(BX), BX#JMP把BX寄存器的包含的地址值放入CPU的IP寄存器，于是，CPU跳转到该地址继续执行指令，JMP    BX

MOVQ    buf+0(FP), BX        # &gp.sched --> BX

MOVQ    gobuf_g(BX), DX  # gp.sched.g --> DX

MOVQ    0(DX), CX        # make sure g != nil

get_tls(CX)
#把DX值也就是需要运行的goroutine的指针写入线程本地存储之中
#运行这条指令之前，线程本地存储存放的是g0的地址
MOVQ    DX, g(CX)

MOVQ    gobuf_sp(BX), SP    # restore SP

#下面三条同样是恢复调度上下文到CPU相关寄存器MOVQ    gobuf_ret(BX), AX #系统调用的返回值放入AX寄存器MOVQ    gobuf_ctxt(BX), DXMOVQ    gobuf_bp(BX), BP#清空gp.sched中不再需要的值，因为我们已把相关值放入CPU对应的寄存器了，不再需要，这样做可以少gc的工作量MOVQ    $0, gobuf_sp(BX)    // clear to help garbage collectorMOVQ    $0, gobuf_ret(BX)MOVQ    $0, gobuf_ctxt(BX)MOVQ    $0, gobuf_bp(BX)

MOVQ    gobuf_pc(BX), BX

JMP    BX

// The main goroutine.
func main() {g := getg()  // g = main goroutine，不再是g0了// ......// Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.// Using decimal instead of binary GB and MB because// they look nicer in the stack overflow failure message.if sys.PtrSize == 8 { //64位系统上每个goroutine的栈最大可达1Gmaxstacksize = 1000000000} else {maxstacksize = 250000000}// Allow newproc to start new Ms.mainStarted = trueif GOARCH != "wasm" { // no threads on wasm yet, so no sysmon//现在执行的是main goroutine，所以使用的是main goroutine的栈，需要切换到g0栈去执行newm()systemstack(func() {//创建监控线程，该线程独立于调度器，不需要跟p关联即可运行newm(sysmon, nil)})}//......//调用runtime包的初始化函数，由编译器实现runtime_init() // must be before defer// Record when the world started.runtimeInitTime = nanotime()gcenable()  //开启垃圾回收器//......//main 包的初始化函数，也是由编译器实现，会递归的调用我们import进来的包的初始化函数fn := main_init // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtimefn()//......//调用main.main函数fn = main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtimefn()//......//进入系统调用，退出进程，可以看出main goroutine并未返回，而是直接进入系统调用退出进程了exit(0)//保护性代码，如果exit意外返回，下面的代码也会让该进程crash死掉for {var x *int32*x = 0}
}