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

基本概念

• 传统并发使用的是:多线程共享内存,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的话说明发生了循环调用。

本文来自:简书

感谢作者:darcyaf

查看原文:golang 源码剖析(1): 运行初始化和包初始化

• 编辑
• 预览