初始化中主要对命令行参数整理，环境变量设置，以及内存分配器，垃圾回收器，并发调度器的工作现场准备

基本概念

• 传统并发使用的是:多线程共享内存,go 使用的是CSP（communicating sequential processes）并发模型,以通信的方式来共享内存.
  go 中使用GPM方式来实现CSP,每个M关联一个P,,goroutine关联哪个P是无法控制的,P中维护了一个goroutin的列表，并用循环的方式取出一个G来关联上P来执行程序.
  // The main concepts are:
  // G - goroutine.
  // M - worker thread, or machine.
  // P - processor, a resource that is required to execute Go code.
  // M must have an associated P to execute Go code, however it can be
  // blocked or in a syscall w/o an associated P.

入口

随便写个demo debug，调用栈如下

main.main at main.go:15
runtime.main at proc.go:203
runtime.goexit at asm_amd64.s:1357
 - Async stack trace
runtime.rt0_go at asm_amd64.s:220

即go进程先启动runtime.main，然后才执行main.main
然后就可以新建一个G和M 开始运行程序.
在runtime/asm_amd64.s中

// The new G calls runtime·main.

    call    runtime·args(sb)
    call    runtime·osinit(sb)
    call    runtime·schedinit(sb)

    // create a new goroutine to start program
    MOVQ    $runtime·mainPC(SB), AX     // entry

    // start this M
    CALL    runtime·mstart(SB)
在runtime

scheduinit 这里启动了一个M(最大10000个),ncpu个P,初始化了一系列东西

// The bootstrap sequence is:
//
//  call osinit
//  call schedinit
//  make & queue new G
//  call runtime·mstart
    tracebackinit()
    moduledataverify()
    stackinit()
    mallocinit()
    mcommoninit(_g_.m)
    cpuinit()       // must run before alginit
    alginit()       // maps must not be used before this call
    modulesinit()   // provides activeModules
    typelinksinit() // uses maps, activeModules
    itabsinit()     // uses activeModules

    msigsave(_g_.m)
    initSigmask = _g_.m.sigmask

    goargs()
    goenvs()
    parsedebugvars()
    gcinit()

    sched.lastpoll = uint64(nanotime())
    procs := ncpu
    if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
        procs = n
    }
    if procresize(procs) != nil {
        throw("unknown runnable goroutine during bootstrap")
    }

包init流程

在src/cmd/compile/internal/gc/noder.go这个路径下，这里会对先解析所有的文件
gc.go中lines := parseFiles(flag.Args())调用解析文件函数,最终会生成一个pkgMap:map[string]*Pkg
接着查找所有的init方法并改名为init.0,init.1累加的名字，屏蔽了init函数防止调用，生成一个.inittask方法方便调用
在gc/init.go中

    nf := initOrder(n) //检查初始化时的包循环引用等问题

    // Record user init functions. 为函数生成别名
    for i := 0; i < renameinitgen; i++ {
        s := lookupN("init.", i)
        fns = append(fns, s.Linksym())
    }
    // Make an .inittask structure.
    sym := lookup(".inittask")
    nn := newname(sym)

在src/runtime/proc.go中:

    //go:linkname runtime_inittask runtime..inittask
    var runtime_inittask initTask
    //go:linkname main_inittask main..inittask
    var main_inittask initTask
    doInit(&runtime_inittask) // must be before defer
    doInit(&main_inittask)
    fn := main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime
    fn()

由此调用init之后再进入main.main入口

包init顺序

go中建议对包的引用只做初始化，不涉及包的顺序
先初始化依赖包,然后对同一个包下多文件按字母顺序初始化，同一文件从上到下init
在src/cmd/compile/internal/gc/initorder.go中

// Assignments are in one of three phases: NotStarted, Pending, or
// Done. For assignments in the Pending phase, we use Xoffset to
// record the number of unique variable dependencies whose
// initialization assignment is not yet Done. We also maintain a
// "blocking" map that maps assignments back to all of the assignments
// that depend on it.
//
// For example, for an initialization like:
//
//     var x = f(a, b, b)
//     var a, b = g()
//
// the "x = f(a, b, b)" assignment depends on two variables (a and b),
// so its Xoffset will be 2. Correspondingly, the "a, b = g()"
// assignment's "blocking" entry will have two entries back to x's
// assignment.

这里的例子中,如果x依赖于a和b,那么x.off+=2,然后将x 添加到blocking[a]和blocking[b]的列表中去。
当a,b初始化完了以后会将x的offset--1。
最后再判断offset，如果offset不为0的话说明发生了循环调用。