main() {
 A()
}

func A() {
  ... 聲明了一些局部變量...
  B(1, 2)
  test := 123
}

func B (a int , b int) {      
  ... 聲明了一些局部變量...
  C()
}

func C (a int, b int , c int) {
   test := 123 
}

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

#define N (1000 * 1000 * 1000)

volatile int g = 0;

void *start(void *arg)
{
        int i;

        for (i = 0; i < N; i++) {
                g++;
        }

        return NULL;
}

int main(int argc, char *argv[])
{
        pthread_t tid;

        // 使用pthread_create函數(shù)創(chuàng)建一個新線程執(zhí)行start函數(shù)
        pthread_create(&tid, NULL, start, NULL);

        for (;;) {
                usleep(1000 * 100 * 5);
                printf("loop g: %d\n", g);
                if (g == N) {
                        break;
                }
        }

        pthread_join(tid, NULL); // 等待子線程結(jié)束運行

        return 0;
}

```c
$./thread
loop g: 98938361
loop g: 198264794
loop g: 297862478
loop g: 396750048
loop g: 489684941
loop g: 584723988
loop g: 679293257
loop g: 777715939
loop g: 876083765
loop g: 974378774
loop g: 1000000000

// 程序啟動時的初始化代碼
......
for i := 0; i < N; i++ { // 創(chuàng)建N個操作系統(tǒng)線程執(zhí)行schedule函數(shù)
     create_os_thread(schedule) // 創(chuàng)建一個操作系統(tǒng)線程執(zhí)行schedule函數(shù)
}

//schedule函數(shù)實現(xiàn)調(diào)度邏輯
func schedule() {
    for { //調(diào)度循環(huán)
          // 根據(jù)某種算法從M個goroutine中找出一個需要運行的goroutine
          g := find_a_runnable_goroutine_from_M_goroutines()
          run_g(g) // CPU運行該goroutine，直到需要調(diào)度其它goroutine才返回
          save_status_of_g(g) // 保存goroutine的狀態(tài)，主要是寄存器的值
      }
}

type g struct { 
    // 記錄該goroutine使用的棧，當前 goroutine 的棧內(nèi)存范圍 [stack.lo, stack.hi)
    stack       stack 
    // 下面兩個成員用于棧溢出檢查，實現(xiàn)棧的自動伸縮，搶占調(diào)度也會用到stackguard0  
    stackguard0 uintptr   

    _panic       *_panic  
    _defer       *_defer  
    // 此goroutine正在被哪個工作線程執(zhí)行
    m            *m       
    // 存儲 goroutine 的調(diào)度相關(guān)的數(shù)據(jù)
    sched        gobuf 
    
 // schedlink字段指向全局運行隊列中的下一個g，
 // 所有位于全局運行隊列中的g形成一個鏈表
 schedlink      guintptr
 
    // 不涉及本篇內(nèi)容的字段已剔除
 ...
}

type gobuf struct {
    // 棧指針，對應(yīng)上文講到的RSP寄存器的值
    sp   uintptr
    // 程序計數(shù)器，對應(yīng)上文講到的RIP寄存器
    pc   uintptr
    // 記錄當前這個gobuf對象屬于哪個goroutine
    g    guintptr 
    // 系統(tǒng)調(diào)用的返回值
    ret  sys.Uintreg
 // 保存CPU的rbp寄存器的值 
 bp   uintptr
    ...
}

// Stack describes a Go execution stack.
// The bounds of the stack are exactly [lo, hi),
// with no implicit data structures on either side.
//用于記錄goroutine使用的棧的起始和結(jié)束位置
type stack struct {  
    lo uintptr    // 棧頂，指向內(nèi)存低地址
    hi uintptr    // 棧底，指向內(nèi)存高地址
}

const (
    //  剛剛被分配并且還沒有被初始化
    _Gidle = iota // 0 
    // 沒有執(zhí)行代碼，沒有棧的所有權(quán)，存儲在運行隊列中
    _Grunnable // 1 
    // 可以執(zhí)行代碼，擁有棧的所有權(quán)，被賦予了內(nèi)核線程 M 和處理器 P
    _Grunning // 2 
    // 正在執(zhí)行系統(tǒng)調(diào)用，擁有棧的所有權(quán)，沒有執(zhí)行用戶代碼，
    // 被賦予了內(nèi)核線程 M 但是不在運行隊列上
    _Gsyscall // 3 
    // 由于運行時而被阻塞，沒有執(zhí)行用戶代碼并且不在運行隊列上，
    // 但是可能存在于 Channel 的等待隊列上
    _Gwaiting // 4  
    // 表示當前goroutine沒有被使用，沒有執(zhí)行代碼，可能有分配的棧
    _Gdead // 6  
    // 棧正在被拷貝，沒有執(zhí)行代碼，不在運行隊列上
    _Gcopystack // 8 
    // 由于搶占而被阻塞，沒有執(zhí)行用戶代碼并且不在運行隊列上，等待喚醒
    _Gpreempted // 9 
    // GC 正在掃描?？臻g，沒有執(zhí)行代碼，可以與其他狀態(tài)同時存在
    _Gscan          = 0x1000 
    ...
)

type m struct {
    // g0主要用來記錄工作線程使用的棧信息，在執(zhí)行調(diào)度代碼時需要使用這個棧 // 執(zhí)行用戶goroutine代碼時，使用用戶goroutine自己的棧，調(diào)度時會發(fā)生棧的切換
    g0      *g       
         
    // 線程本地存儲 thread-local，通過TLS實現(xiàn)m結(jié)構(gòu)體對象與工作線程之間的綁定，下文會詳細介紹
    tls           [6]uintptr   // thread-local storage (for x86 extern register)
    // 當前運行的G
    curg          *g       // current running goroutine
    // 正在運行代碼的P
    p             puintptr // attached p for executing go code (nil if not executing go code)
    nextp         puintptr
    // 之前使用的P
    oldp          puintptr  
 
 // 記錄所有工作線程的一個鏈表
    alllink       *m // on allm
    schedlink     muintptr

    // Linux平臺thread的值就是操作系統(tǒng)線程ID
    thread        uintptr // thread handle
    freelink      *m      // on sched.freem
    ...
}

type p struct {
    id          int32
    // p 的狀態(tài)
    status      uint32  
    // 調(diào)度器調(diào)用會+1
    schedtick   uint32     // incremented on every scheduler call
    // 系統(tǒng)調(diào)用會+1
    syscalltick uint32     // incremented on every system call
    // 對應(yīng)關(guān)聯(lián)的 M
    m           muintptr    
    mcache      *mcache
    pcache      pageCache 
    // defer 結(jié)構(gòu)池
    deferpool    [5][]*_defer  
    deferpoolbuf [5][32]*_defer  
    // 可運行的 goroutine 隊列，可無鎖訪問
    runqhead uint32
    runqtail uint32
    runq     [256]guintptr
    // 緩存可立即執(zhí)行的 G
    runnext guintptr 
    // 可用的 G 列表，G 狀態(tài)等于 Gdead 
    gFree struct {
        gList
        n int32
    }
    ...
}

const ( 
    // 表示P沒有運行用戶代碼或者調(diào)度器 
    _Pidle = iota 
    // 被線程 M 持有，并且正在執(zhí)行用戶代碼或者調(diào)度器
    _Prunning 
    // 沒有執(zhí)行用戶代碼，當前線程陷入系統(tǒng)調(diào)用
    _Psyscall
    // 被線程 M 持有，當前處理器由于垃圾回收 STW 被停止
    _Pgcstop 
    // 當前處理器已經(jīng)不被使用
    _Pdead
)

type schedt struct {
    ...
 // 鎖，從全局隊列獲取G時需要使用到
    lock mutex 
    // 空閑的 M 列表
    midle        muintptr  
    // 空閑的 M 列表數(shù)量
    nmidle       int32      
    // 下一個被創(chuàng)建的 M 的 id
    mnext        int64  
    // 能擁有的最大數(shù)量的 M  
    maxmcount    int32    
    // 由空閑的p結(jié)構(gòu)體對象組成的鏈表
    pidle      puintptr // idle p's
    // 空閑 p 數(shù)量
    npidle     uint32

    // 全局 runnable G 隊列
    runq     gQueue
    runqsize int32  
 
    // 有效 dead G 的全局緩存.
    gFree struct {
        lock    mutex
        stack   gList // Gs with stacks
        noStack gList // Gs without stacks
        n       int32
    } 
    // sudog 結(jié)構(gòu)的集中緩存
    sudoglock  mutex
    sudogcache *sudog 
    // defer 結(jié)構(gòu)的池
    deferlock mutex
    deferpool [5]*_defer 
    ...
}

allgs     []*g     // 保存所有的g
allm       *m    // 所有的m構(gòu)成的一個鏈表，包括下面的m0
allp       []*p    // 保存所有的p，len(allp) == gomaxprocs

ncpu             int32   // 系統(tǒng)中cpu核的數(shù)量，程序啟動時由runtime代碼初始化
gomaxprocs int32   // p的最大值，默認等于ncpu，但可以通過GOMAXPROCS修改

sched      schedt     // 調(diào)度器結(jié)構(gòu)體對象，記錄了調(diào)度器的工作狀態(tài)

m0  m       // 代表進程的主線程
g0   g        // m0的g0，也就是m0.g0 = &g0

// 程序啟動時的初始化代碼
......
for i := 0; i < N; i++ { // 創(chuàng)建N個操作系統(tǒng)線程執(zhí)行schedule函數(shù)
     create_os_thread(schedule) // 創(chuàng)建一個操作系統(tǒng)線程執(zhí)行schedule函數(shù)
}


// 定義一個線程私有全局變量，注意它是一個指向m結(jié)構(gòu)體對象的指針
// ThreadLocal用來定義線程私有全局變量
ThreadLocal self *m
//schedule函數(shù)實現(xiàn)調(diào)度邏輯
func schedule() {
    // 創(chuàng)建和初始化m結(jié)構(gòu)體對象，并賦值給私有全局變量self
    self = initm()  
    for { //調(diào)度循環(huán)
          if (self.p.runqueue is empty) {
                 // 根據(jù)某種算法從全局運行隊列中找出一個需要運行的goroutine
                 g := find_a_runnable_goroutine_from_global_runqueue()
           } else {
                 // 根據(jù)某種算法從私有的局部運行隊列中找出一個需要運行的goroutine
                 g := find_a_runnable_goroutine_from_local_runqueue()
           }
          run_g(g) // CPU運行該goroutine，直到需要調(diào)度其它goroutine才返回
          save_status_of_g(g) // 保存goroutine的狀態(tài)，主要是寄存器的值
     }
}

package main

import "fmt"

func main() {
    fmt.Println("Hello World!")
}

TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
    // copy arguments forward on an even stack
    MOVQ   DI, AX    // 這行代碼將寄存器 `DI` 的值（通常是命令行參數(shù)的數(shù)量，即 `argc`）復制到寄存器 `AX` 中。`AX` 現(xiàn)在存儲了程序的參數(shù)個數(shù)
    MOVQ   SI, BX    // 這行代碼將寄存器 `SI` 的值（通常是指向命令行參數(shù)字符串數(shù)組的指針，即 `argv`）復制到寄存器 `BX` 中。`BX` 現(xiàn)在存儲了指向命令行參數(shù)的指針。
    SUBQ   $(5*8), SP    // 這行代碼從棧指針 `SP` 中減去 `40` 字節(jié)（`5*8`），為局部變量和函數(shù)參數(shù)分配空間。這里的 `5` 可能表示 3 個參數(shù)和 2 個自動變量（局部變量）。這行代碼的目的是在棧上為這些變量留出空間。
    ANDQ   $~15, SP // 這行代碼將棧指針 `SP` 對齊到 16 字節(jié)的邊界。確保棧在函數(shù)調(diào)用時是對齊的
    MOVQ   AX, 24(SP) // 這行代碼將 `AX` 中的值（即 `argc`）存儲到棧上相對于 `SP` 的偏移量 +`24` 的位置。
    MOVQ   BX, 32(SP) // - 這行代碼將 `BX` 中的值（即 `argv`）存儲到棧上相對于 `SP` 的偏移量 +`32` 的位置。

從系統(tǒng)線程的棧中劃分出一部分作為g0的棧,然后初始化g0的棧信息和stackgard
 MOVQ $runtime·g0(SB), DI  // 把g0的地址放入寄存器DI
 LEAQ (-64*1024)(SP), BX   // 設(shè)置寄存器BX的值為 SP（主線程棧棧頂指針） - 64k 的位置
 MOVQ BX, g_stackguard0(DI) // g0.stackguard0 = BX ， 也就是設(shè)置g0.stackguard0 指向主線程棧的棧頂-64k的位置
 MOVQ BX, g_stackguard1(DI) //g0.stackguard1 = SP - 64k
 MOVQ BX, (g_stack+stack_lo)(DI) //g0.stack_lo = SP - 64k
 MOVQ SP, (g_stack+stack_hi)(DI) //g0.stack_lo = SP

LEAQ runtime·m0+m_tls(SB), DI    // DI = &m0.tls，取m0的tls成員的地址到DI寄存器
 CALL runtime·settls(SB)  // 調(diào)用settls設(shè)置線程本地存儲，settls函數(shù)的參數(shù)在DI寄存器中

 // store through it, to make sure it works
 // 驗證settls是否可以正常工作，如果有問題則abort退出程序
 get_tls(BX)  //獲取fs段基地址并放入BX寄存器，其實就是m0.tls[1]的地址，get_tls的代碼由編譯器生成
 MOVQ $0x123, g(BX) //把整型常量0x123設(shè)置到線程本地存儲中
 MOVQ runtime·m0+m_tls(SB), AX  //獲取m.tls結(jié)構(gòu)體的地址到AX寄存器中
 CMPQ AX, $0x123 // 判斷m.tls[0]的值是否等于123，是的話說明tls工作正常
 JEQ 2(PC)
 CALL runtime·abort(SB)

ok:
 // set the per-goroutine and per-mach "registers"
 get_tls(BX) //獲取fs段基址到BX寄存器
 LEAQ runtime·g0(SB), CX //CX = g0的地址
 MOVQ CX, g(BX)  //把g0的地址保存在線程本地存儲里面，也就是m0.tls[0]=&g0
 LEAQ runtime·m0(SB), AX //AX = m0的地址

 // 下面把m0和g0關(guān)聯(lián)起來m0->g0 = g0，g0->m = m0 // save m->g0 = g0
 
 // save m->g0 = g0
 MOVQ CX, m_g0(AX) //m0.g0 = g0
 // save m0 to g0->m
 MOVQ AX, g_m(CX) //g0.m = m0

CALL runtime·check(SB)

 MOVL 24(SP), AX  // copy argc
 MOVL AX, 0(SP)
 MOVQ 32(SP), AX  // copy argv
 MOVQ AX, 8(SP)
 CALL runtime·args(SB)
 CALL runtime·osinit(SB)
 
 // 調(diào)度器初始化
 CALL runtime·schedinit(SB)

 // 新建一個 goroutine，該 goroutine 綁定 runtime.main
 MOVQ $runtime·mainPC(SB), AX  // entry
 PUSHQ AX
 CALL runtime·newproc(SB)
 POPQ AX

 // 啟動M，開始調(diào)度循環(huán)，運行剛剛創(chuàng)建的goroutine
 CALL runtime·mstart(SB)

 // 上面的mstart永遠不應(yīng)該返回的，如果返回了，一定是代碼邏輯有問題，直接abort
 CALL runtime·abort(SB) // mstart should never return
 RET

func schedinit() {
// raceinit must be the first call to race detector.
// In particular, it must be done before mallocinit below calls racemapshadow.
   
    //getg函數(shù)在源代碼中沒有對應(yīng)的定義，由編譯器插入類似下面兩行代碼
    //get_tls(CX)
    //MOVQ g(CX), BX; BX存器里面現(xiàn)在放的是當前g結(jié)構(gòu)體對象的地址
    _g_ := getg() // _g_ = &g0

    ......

    //設(shè)置最多啟動10000個操作系統(tǒng)線程，也是最多10000個M
    sched.maxmcount = 10000

    ......
   
    mcommoninit(_g_.m) //初始化m0，因為從前面的代碼我們知道g0->m = &m0

    ......

    sched.lastpoll = uint64(nanotime())
    procs := ncpu  //系統(tǒng)中有多少核，就創(chuàng)建和初始化多少個p結(jié)構(gòu)體對象
    if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
        procs = n //如果環(huán)境變量指定了GOMAXPROCS，則創(chuàng)建指定數(shù)量的p
    }
    if procresize(procs) != nil {//創(chuàng)建和初始化全局變量allp
        throw("unknown runnable goroutine during bootstrap")
    }

    ......
}

func mcommoninit(mp *m, id int64) {
    _g_ := getg()
    ...
    lock(&sched.lock)
    // 如果傳入id小于0，那么id則從mReserveID獲取，初次從mReserveID獲取id為0
    if id >= 0 {
        mp.id = id
    } else {
        mp.id = mReserveID()
    }
    //random初始化，用于竊取 G
    mp.fastrand[0] = uint32(int64Hash(uint64(mp.id), fastrandseed))
    mp.fastrand[1] = uint32(int64Hash(uint64(cputicks()), ^fastrandseed))
    if mp.fastrand[0]|mp.fastrand[1] == 0 {
        mp.fastrand[1] = 1
    }
    // 創(chuàng)建用于信號處理的gsignal，只是簡單的從堆上分配一個g結(jié)構(gòu)體對象,然后把棧設(shè)置好就返回了
    mpreinit(mp)
    if mp.gsignal != nil {
        mp.gsignal.stackguard1 = mp.gsignal.stack.lo + _StackGuard
    }

    // 把 M 掛入全局鏈表allm之中
    mp.alllink = allm
    ...
}

m0.p = allp[0]
allp[0].m = &m0

func procresize(nprocs int32) *p {
    old := gomaxprocs //系統(tǒng)初始化時 gomaxprocs = 0

    ......

    // Grow allp if necessary.
    if nprocs > int32(len(allp)) { //初始化時 len(allp) == 0
        // 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 { 
   //初始化時進入此分支，創(chuàng)建allp 切片
            nallp := make([]*p, nprocs)
            // 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
    //循環(huán)創(chuàng)建nprocs個p并完成基本初始化
    for i := int32(0); i < nprocs; i++ {
        pp := allp[i]
        if pp == nil {
            pp = new(p)//調(diào)用內(nèi)存分配器從堆上分配一個struct p
            pp.id = i
            pp.status = _Pgcstop
            ......
            atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
        }

        ......
    }

    ......

    _g_ := getg()  // _g_ = g0
    if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs {//初始化時m0->p還未初始化，所以不會執(zhí)行這個分支
        // continue to use the current P
        _g_.m.p.ptr().status = _Prunning
        _g_.m.p.ptr().mcache.prepareForSweep()
    } else {
  //初始化時執(zhí)行這個分支
        // release the current P and acquire allp[0]
        if _g_.m.p != 0 {//初始化時這里不執(zhí)行
            _g_.m.p.ptr().m = 0
        }
        _g_.m.p = 0
        _g_.m.mcache = nil
        p := allp[0]
        p.m = 0
        p.status = _Pidle
        acquirep(p) //把p和m0關(guān)聯(lián)起來，其實是這兩個strct的成員相互賦值
        if trace.enabled {
            traceGoStart()
        }
    }
   
    //下面這個for 循環(huán)把所有空閑的p放入空閑鏈表
    var runnablePs *p
    for i := nprocs - 1; i >= 0; i-- {
        p := allp[i]
        if _g_.m.p.ptr() == p {//allp[0]跟m0關(guān)聯(lián)了，所以是不能放任
            continue
        }
        p.status = _Pidle
        if runqempty(p) {//初始化時除了allp[0]其它p全部執(zhí)行這個分支，放入空閑鏈表
            pidleput(p)
        } else {
            ......
        }
    }

    ......
   
    return runnablePs
}

func start(a, b, c int64) {
    ......
}

func main() {
    go start(1, 2, 3)
}

func main() {
    push 0x3
    push 0x2
    push 0x1
    runtime.newproc(24, start)
}

// Create a new g running fn with siz bytes of arguments.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.
// Cannot split the stack because it assumes that the arguments
// are available sequentially after &fn; they would not be
// copied if a stack split occurred.
//go:nosplit
func newproc(siz int32, fn *funcval) {
    //函數(shù)調(diào)用參數(shù)入棧順序是從右向左，而且棧是從高地址向低地址增長的
    //注意：argp指向fn函數(shù)的第一個參數(shù)，而不是newproc函數(shù)的參數(shù)
    //參數(shù)fn在棧上的地址+8的位置存放的是fn函數(shù)的第一個參數(shù)
    argp := add(unsafe.Pointer(&fn), sys.PtrSize)
    gp := getg()  //獲取正在運行的g，初始化時是m0.g0
   
    //getcallerpc()返回一個地址，也就是調(diào)用newproc時由call指令壓棧的函數(shù)返回地址，
    //對于我們現(xiàn)在這個場景來說，pc就是CALLruntime·newproc(SB)指令后面的POPQ AX這條指令的地址
    pc := getcallerpc()
   
    //systemstack的作用是切換到g0棧執(zhí)行作為參數(shù)的函數(shù)
    //我們這個場景現(xiàn)在本身就在g0棧，因此什么也不做，直接調(diào)用作為參數(shù)的函數(shù)
    systemstack(func() {
        newproc1(fn, (*uint8)(argp), siz, gp, pc)
    })
}

type funcval struct {
    fn uintptr
    // variable-size, fn-specific data here
}

// Create a new g running fn with narg bytes of arguments starting
// at argp. callerpc is the address of the go statement that created
// this. The new g is put on the queue of g's waiting to run.
func newproc1(fn *funcval, argp *uint8, narg int32, callergp *g, callerpc uintptr) {
    //因為已經(jīng)切換到g0棧，所以無論什么場景都有 _g_ = g0，當然這個g0是指當前工作線程的g0
    //對于我們這個場景來說，當前工作線程是主線程，所以這里的g0 = m0.g0
    _g_ := getg()

    ......

    _p_ := _g_.m.p.ptr() //初始化時_p_ = g0.m.p，從前面的分析可以知道其實就是allp[0]
    newg := gfget(_p_) //從p的本地緩沖里獲取一個沒有使用的g，初始化時沒有，返回nil
    if newg == nil {
         //new一個g結(jié)構(gòu)體對象，然后從堆上為其分配棧，并設(shè)置g的stack成員和兩個stackgard成員
        newg = malg(_StackMin)
        casgstatus(newg, _Gidle, _Gdead) //初始化g的狀態(tài)為_Gdead
         //放入全局變量allgs切片中
        allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
    }
   
    ......
   
    //調(diào)整g的棧頂置針，無需關(guān)注
    totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
    totalSize += -totalSize & (sys.SpAlign - 1)                  // align to spAlign
    sp := newg.stack.hi - totalSize
    spArg := sp

    //......
   
    if narg > 0 {
         //把參數(shù)從執(zhí)行newproc函數(shù)的棧（初始化時是g0棧）拷貝到新g的棧
        memmove(unsafe.Pointer(spArg), unsafe.Pointer(argp), uintptr(narg))
        // ......
    }

//把newg.sched結(jié)構(gòu)體成員的所有成員設(shè)置為0
    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
   
    //設(shè)置newg的sched成員，調(diào)度器需要依靠這些字段才能把goroutine調(diào)度到CPU上運行。
    newg.sched.sp = sp  //newg的棧頂
    newg.stktopsp = sp
    //newg.sched.pc表示當newg被調(diào)度起來運行時從這個地址開始執(zhí)行指令
    //把pc設(shè)置成了goexit這個函數(shù)偏移1（sys.PCQuantum等于1）的位置，
    //至于為什么要這么做需要等到分析完gostartcallfn函數(shù)才知道
    newg.sched.pc = funcPC(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
    newg.sched.g = guintptr(unsafe.Pointer(newg))

    gostartcallfn(&newg.sched, fn) //調(diào)整sched成員和newg的棧
// adjust Gobuf as if it executed a call to fn
// and then did an immediate gosave.
func gostartcallfn(gobuf *gobuf, fv *funcval) {
    var fn unsafe.Pointer
    if fv != nil {
        fn = unsafe.Pointer(fv.fn) //fn: goroutine的入口地址，初始化時對應(yīng)的是runtime.main
    } else {
        fn = unsafe.Pointer(funcPC(nilfunc))
    }
    gostartcall(gobuf, fn, unsafe.Pointer(fv))
}
// adjust Gobuf as if it executed a call to fn with context ctxt
// and then did an immediate gosave.
func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
    sp := buf.sp //newg的棧頂，目前newg棧上只有fn函數(shù)的參數(shù)，sp指向的是fn的第一參數(shù)
    if sys.RegSize > sys.PtrSize {
        sp -= sys.PtrSize
        *(*uintptr)(unsafe.Pointer(sp)) = 0
    }
    sp -= sys.PtrSize //為返回地址預留空間，
    //這里在偽裝fn是被goexit函數(shù)調(diào)用的，使得fn執(zhí)行完后返回到goexit繼續(xù)執(zhí)行，從而完成清理工作
    *(*uintptr)(unsafe.Pointer(sp)) = buf.pc //在棧上放入goexit+1的地址
    buf.sp = sp //重新設(shè)置newg的棧頂寄存器
    //這里才真正讓newg的ip寄存器指向fn函數(shù)，注意，這里只是在設(shè)置newg的一些信息，newg還未執(zhí)行，
    //等到newg被調(diào)度起來運行時，調(diào)度器會把buf.pc放入cpu的IP寄存器，
    //從而使newg得以在cpu上真正的運行起來
    buf.pc = uintptr(fn)
    buf.ctxt = ctxt
}

//newg真正從哪里開始執(zhí)行并不依賴于這個成員，而是sched.pc
    newg.startpc = fn.fn  

    ......
   
    //設(shè)置g的狀態(tài)為_Grunnable，表示這個g代表的goroutine可以運行了
    casgstatus(newg, _Gdead, _Grunnable)

    ......
   
    //把newg放入_p_的運行隊列，初始化的時候一定是p的本地運行隊列，其它時候可能因為本地隊列滿了而放入全局隊列
    runqput(_p_, newg, true)

    ......
}

func mstart0() {
    gp := getg()

    ...
    // Initialize stack guard so that we can start calling regular
    // Go code.
    gp.stackguard0 = gp.stack.lo + stackGuard
    gp.stackguard1 = gp.stackguard0
 
    mstart1()

    // 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
    }
}

func mstart1() {
    // 啟動過程時 _g_ = m0.g0
    _g_ := getg()

 //getcallerpc()獲取mstart1執(zhí)行完的返回地址
    //getcallersp()獲取調(diào)用mstart1時的棧頂?shù)刂?    save(getcallerpc(), getcallersp())
    ...
    // 進入調(diào)度循環(huán)。永不返回
    schedule()

gp.sched.pc = getcallerpc()
gp.sched.sp = getcallersp()

// One round of scheduler: find a runnable goroutine and execute it.

// Never returns.
func schedule() {
    _g_ := getg()  //_g_ = 每個工作線程m對應(yīng)的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.
        //為了保證調(diào)度的公平性，每進行61次調(diào)度就需要優(yōu)先從全局運行隊列中獲取goroutine，
        //因為如果只調(diào)度本地隊列中的g，那么全局運行隊列中的goroutine將得不到運行
        if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
            lock(&sched.lock) //所有工作線程都能訪問全局運行隊列，所以需要加鎖
            gp = globrunqget(_g_.m.p.ptr(), 1) //從全局運行隊列中獲取1個goroutine
            unlock(&sched.lock)
        }
    }
    if gp == nil {
        //從與m關(guān)聯(lián)的p的本地運行隊列中獲取goroutine
        gp, inheritTime = runqget(_g_.m.p.ptr())
        if gp != nil && _g_.m.spinning {
            throw("schedule: spinning with local work")
        }
    }
    if gp == nil {
        //如果從本地運行隊列和全局運行隊列都沒有找到需要運行的goroutine，
        //則調(diào)用findrunnable函數(shù)從其它工作線程的運行隊列中偷取，如果偷取不到，則當前工作線程進入睡眠，
        //直到獲取到需要運行的goroutine之后findrunnable函數(shù)才會返回。
      gp, inheritTime = findrunnable() // blocks until work is available
    }
    //跟啟動無關(guān)的代碼.....
    //當前運行的是runtime的代碼，函數(shù)調(diào)用棧使用的是g0的棧空間
    //調(diào)用execte切換到gp的代碼和?？臻g去運行
    execute(gp, inheritTime)  
}

func execute(gp *g, inheritTime bool) {
    _g_ := getg() //g0
    //設(shè)置待運行g(shù)的狀態(tài)為_Grunning
    casgstatus(gp, _Grunnable, _Grunning)
  
    //......
    
    //把g和m關(guān)聯(lián)起來
    _g_.m.curg = gp 
    gp.m = _g_.m
    //......
    //gogo完成從g0到gp真正的切換
    gogo(&gp.sched)
}

TEXT runtime·gogo(SB), NOSPLIT, $16-8
    //buf = &gp.sched
    MOVQ  buf+0(FP), BX   # BX = buf
  
    //gobuf->g --> dx register
    MOVQ  gobuf_g(BX), DX  # DX = gp.sched.g
  
    //下面這行代碼沒有實質(zhì)作用，檢查gp.sched.g是否是nil，如果是nil進程會crash死掉
    MOVQ  0(DX), CX   # make sure g != nil
  
    get_tls(CX) 
  
    //把要運行的g的指針放入線程本地存儲，這樣后面的代碼就可以通過線程本地存儲
    //獲取到當前正在執(zhí)行的goroutine的g結(jié)構(gòu)體對象，從而找到與之關(guān)聯(lián)的m和p
    MOVQ  DX, g(CX)
  
    //把CPU的SP寄存器設(shè)置為sched.sp，完成了棧的切換(畫重點！)
    MOVQ  gobuf_sp(BX), SP  # restore SP
  
    //下面三條同樣是恢復調(diào)度上下文到CPU相關(guān)寄存器
    MOVQ  gobuf_ret(BX), AX
    MOVQ  gobuf_ctxt(BX), DX
    MOVQ  gobuf_bp(BX), BP
  
    //清空sched的值，因為我們已把相關(guān)值放入CPU對應(yīng)的寄存器了，不再需要，這樣做可以少gc的工作量
    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)
  
    //把sched.pc值放入BX寄存器
    MOVQ  gobuf_pc(BX), BX
  
    //JMP把BX寄存器的包含的地址值放入CPU的IP寄存器，于是，CPU跳轉(zhuǎn)到該地址繼續(xù)執(zhí)行指令，
    JMP BX

schedule()->execute()->gogo()->aa()->goexit()->goexit1()->mcall()->goexit0()->schedule()