初始化中主要对命令行参数整理，环境变量设置，以及内存分配器，垃圾回收器，并发调度器的工作现场准备
基本概念
- 传统并发使用的是:
多线程共享内存,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的话说明发生了循环调用。
