mstartfn func
//当前运行的用户 goroutine 的 g 结构体对象
curg *g // current running goroutine
caughtsig guintptr // goroutine running during fatal signal
//当前工作线程绑定的 P，如果没有就为 nil
p puintptr // attached p for executing go code (nil if not executing go code)
//暂存与当前 M 潜在关联的 P
nextp puintptr
//M 之前调用的 P
oldp puintptr // the p that was attached before executing a syscall
id int64
mallocing int32
throwing int32
//当前 M 是否关闭抢占式调度
preemptoff string// if != "", keep curg running on this m
locks int32
dying int32
profilehz int32
//M 的自旋状态，为 true 时 M 处于自旋状态，正在从其他线程偷 G; 为 false，休眠状态
spinning bool// m is out of work and is actively looking for work
blocked bool// m is blocked on a note
newSigstack bool// minit on C thread called sigaltstack
printlock int8
incgo bool// m is executing a cgo call
freeWait uint32// if == 0, safe to free g0 and delete m (atomic)
fastrand [ 2] uint32
needextram bool
traceback uint8
ncgocall uint64// number of cgo calls in total
ncgo int32// number of cgo calls currently in progress
cgoCallersUse uint32// if non-zero, cgoCallers in use temporarily
cgoCallers *cgoCallers // cgo traceback if crashing in cgo call
//没有 goroutine 运行时，工作线程睡眠
//通过这个来唤醒工作线程
park note // 休眠锁
//记录所有工作线程的链表
alllink *m // on allm
schedlink muintptr
//当前线程内存分配的本地缓存
mcache *mcache
//当前 M 锁定的 G，
lockedg guintptr
createstack [ 32] uintptr// stack that created this thread.
lockedExt uint32// tracking for external LockOSThread
lockedInt uint32// tracking for internal lockOSThread
nextwaitm muintptr // next m waiting for lock
waitunlockf func(*g, unsafe.Pointer)bool
waitlock unsafe.Pointer
waittraceev byte
waittraceskip int
startingtrace bool
syscalltick uint32
//操作系统线程 id
thread uintptr// thread handle
freelink *m // on sched.freem
// these are here because they are too large to be on the stack
// of low-level NOSPLIT functions.
libcall libcall
libcallpc uintptr// for cpu profiler
libcallsp uintptr
libcallg guintptr
syscall libcall // stores syscall parameters on windows
vdsoSP uintptr// SP for traceback while in VDSO call (0 if not in call)
vdsoPC uintptr// PC for traceback while in VDSO call
dlogPerM
mOS
}
看看几个比较重要的字段：g0：用于执行调度器的 g0gsignal：用于信号处理tls：线程本地存储的 tlsp：goroutine 绑定的本地资源
P 结构体
一个 M 要运行，必须绑定 P 才能运行 goroutine，M 阻塞时，P 会被传给其他 M。
/src/runtime/runtime2.go
Copytype p struct{
//allp 中的索引
id int32
//p 的状态
status uint32// one of pidle/prunning/...
link puintptr
schedtick uint32// incremented on every scheduler call->每次 scheduler 调用+1
syscalltick uint32// incremented on every system call->每次系统调用+1
sysmontick sysmontick // last tick observed by sysmon
//指向绑定的 m，如果 p 是 idle 的话，那这个指针是 nil
m muintptr // back-link to associated m (nil if idle)
mcache *mcache
raceprocctx uintptr
//不同大小可用 defer 结构池
deferpool [ 5][]*_defer // pool of available defer structs of different sizes (see panic.go)
deferpoolbuf [ 5][ 32]*_defer
// Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
goidcache uint64
goidcacheend uint64
//本地运行队列，可以无锁访问
// Queue of runnable goroutines. Accessed without lock.
runqhead uint32//队列头
runqtail uint32//队列尾
//数组实现的循环队列
runq [ 256]guintptr
// runnext, if non-nil, is a runnable G that was ready'd by
// the current G and should be run next instead of what's in
// runq if there's time remaining in the running G's time
// slice. It will inherit the time left in the current time
// slice. If a set of goroutines is locked in a
// communicate-and-wait pattern, this schedules that set as a
// unit and eliminates the (potentially large) scheduling
// latency that otherwise arises from adding the ready'd
// goroutines to the end of the run queue.
// runnext 非空时，代表的是一个 runnable 状态的 G，
//这个 G 被 当前 G 修改为 ready 状态，相比 runq 中的 G 有更高的优先级。
//如果当前 G 还有剩余的可用时间，那么就应该运行这个 G
//运行之后，该 G 会继承当前 G 的剩余时间
runnext guintptr
// Available G's (status == Gdead)
//空闲的 g
gFree struct{
gList
n int32
}
sudogcache []*sudog
sudogbuf [ 128]*sudog
tracebuf traceBufPtr
// traceSweep indicates the sweep events should be traced.
// This is used to defer the sweep start event until a span
// has actually been swept.
traceSweep bool
// traceSwept and traceReclaimed track the number of bytes
// swept and reclaimed by sweeping in the current sweep loop.
traceSwept, traceReclaimed uintptr
palloc persistentAlloc // per-P to avoid mutex
_ uint32// Alignment for atomic fields below
// Per-P GC state
gcAssistTime int64// Nanoseconds in assistAlloc
gcFractionalMarkTime int64// Nanoseconds in fractional mark worker (atomic)
gcBgMarkWorker guintptr // (atomic)
gcMarkWorkerMode gcMarkWorkerMode
// gcMarkWorkerStartTime is the nanotime at which this mark
// worker started.
gcMarkWorkerStartTime int64
// gcw is this P's GC work buffer cache. The work buffer is
// filled by write barriers, drained by mutator assists, and
// disposed on certain GC state transitions.
gcw gcWork
// wbBuf is this P's GC write barrier buffer.
//
// TODO:Consider caching this in the running G.
wbBuf wbBuf
runSafePointFn uint32// if 1, run sched.safePointFn at next safe point
pad cpu.CacheLinePad
}
其他的一些字段就是 gc，trace，debug 信息
G 结构体
G 就是 goroutine。主要保存 goroutine 的所有信息以及栈信息，gobuf 结构体：cpu 里的寄存器信息，以便在轮到本 goroutine 执行时，知道从哪里开始执行。
/src/runtime/runtime2.go
Copytype stack struct{
lo uintptr//栈顶，指向内存低地址
hi uintptr//栈底，指向内存搞地址
}
typeg struct{
// Stack parameters.
// stack describes the actual stack memory: [stack.lo, stack.hi).
// stackguard0 is the stack pointer compared in the Go stack growth prologue.
// It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
// stackguard1 is the stack pointer compared in the C stack growth prologue.
// It is stack.lo+StackGuard on g0 and gsignal stacks.
// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
// 记录该 goroutine 使用的栈
stack stack // offset known to runtime/cgo
//下面两个成员用于栈溢出检查，实现栈的自动伸缩，抢占调度也会用到 stackguard0
stackguard0 uintptr// offset known to liblink
stackguard1 uintptr// offset known to liblink
_panic *_panic // innermost panic - offset known to liblink
_defer *_defer // innermost defer
// 此 goroutine 正在被哪个工作线程执行
m *m // current m; offset known to arm liblink
//这个字段跟调度切换有关，G 切换时用来保存上下文，保存什么，看下面 gobuf 结构体
sched gobuf
syscallsp uintptr// if status==Gsyscall, syscallsp = sched.sp to use during gc
syscallpc uintptr// if status==Gsyscall, syscallpc = sched.pc to use during gc
stktopsp uintptr// expected sp at top of stack, to check in traceback
param unsafe.Pointer // passed parameter on wakeup，wakeup 唤醒时传递的参数
// 状态 Gidle,Grunnable,Grunning,Gsyscall,Gwaiting,Gdead
atomicstatus uint32
stackLock uint32// sigprof/scang lock; TODO:fold in to atomicstatus
goid int64
//schedlink 字段指向全局运行队列中的下一个 g，
//所有位于全局运行队列中的 g 形成一个链表
schedlink guintptr
waitsince int64// approx time when the g become blocked
waitreason waitReason // if status==Gwaiting，g 被阻塞的原因
//抢占信号，stackguard0 = stackpreempt，如果需要抢占调度，设置 preempt 为 true
preempt bool// preemption signal, duplicates stackguard0 = stackpreempt
paniconfault bool// panic (instead of crash) on unexpected fault address
preemptscan bool// preempted g does scan for gc
gcscandone bool// g has scanned stack; protected by _Gscan bit in status
gcscanvalid bool// false at start of gc cycle, true if G has not run since last scan; TODO:remove?
throwsplit bool// must not split stack
raceignore int8// ignore race detection events
sysblocktraced bool// StartTrace has emitted EvGoInSyscall about this goroutine
sysexitticks int64// cputicks when syscall has returned (for tracing)
traceseq uint64// trace event sequencer
tracelastp puintptr // last P emitted an event for this goroutine
// 如果调用了 LockOsThread，那么这个 g 会绑定到某个 m 上
lockedm muintptr
sig uint32
writebuf [] byte
sigcode0 uintptr
sigcode1 uintptr
sigpc uintptr
// 创建这个 goroutine 的 go 表达式的 pc
gopc uintptr// pc of go statement that created this goroutine
ancestors *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
startpc uintptr// pc of goroutine function
racectx uintptr
waiting *sudog // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
cgoCtxt [] uintptr// cgo traceback context
labels unsafe.Pointer // profiler labels
timer *timer // cached timer for time.Sleep, 为 time.Sleep 缓存的计时器
selectDone uint32// are we participating in a select and did someone win the race?
// Per-G GC state
// gcAssistBytes is this G's GC assist credit in terms of
// bytes allocated. If this is positive, then the G has credit
// to allocate gcAssistBytes bytes without assisting. If this
// is negative, then the G must correct this by performing
// scan work. We track this in bytes to make it fast to update
// and check for debt in the malloc hot path. The assist ratio
// determines how this corresponds to scan work debt.
gcAssistBytes int64
}
gobuf
gobuf 结构体用于保存 goroutine 的调度信息，主要包括 CPU 的几个寄存器的值。
/src/runtime/runtime2.go
Copytype gobuf struct{
// The offsets of sp, pc, and g are known to (hard-coded in) libmach.
//
// ctxt is unusual with respect to GC: it may be a
// heap-allocated funcval, so GC needs to track it, but it
// needs to be set and cleared from assembly, where it's
// difficult to have write barriers. However, ctxt is really a
// saved, live register, and we only ever exchange it between
// the real register and the gobuf. Hence, we treat it as a
// root during stack scanning, which means assembly that saves
// and restores it doesn't need write barriers. It's still
// typed as a pointer so that any other writes from Go get
// write barriers.
sp uintptr// 保存 CPU 的 rsp 寄存器的值
pc uintptr// 保存 CPU 的 rip 寄存器的值
g guintptr // 记录当前这个 gobuf 对象属于哪个 goroutine
ctxt unsafe.Pointer
//保存系统调用的返回值，因为从系统调用返回之后如果 p 被其它工作线程抢占，
//则这个 goroutine 会被放入全局运行队列被其它工作线程调度，其它线程需要知道系统调用的返回值。
ret sys.Uintreg // 保存系统调用的返回值
lr uintptr
//保存 CPU 的 rip 寄存器的值
bp uintptr// for GOEXPERIMENT=framepointer
}
调度器 sched 结构
所有的 gorouteine 都是被调度器调度运行，调度器持有全局资源
sched
/src/runtime/runtime2.go
Copytype schedt struct{
// accessed atomically. keep at top to ensure alignment on 32-bit systems.
// 需以原子访问访问。
// 保持在 struct 顶部，以使其在 32 位系统上可以对齐
goidgen uint64
lastpoll uint64
lock mutex
// When increasing nmidle, nmidlelocked, nmsys, or nmfreed, be
// sure to call checkdead.
//由空闲的工作线程组成的链表
midle muintptr // idle m's waiting for work
//空闲的工作线程的数量
nmidle int32// number of idle m's waiting for work
//空闲的且被 lock 的 m 计数
nmidlelocked int32// number of locked m's waiting for work
//已经创建的多个 m，下一个 m id
mnext int64// number of m's that have been created and next M ID
//被允许创建的最大 m 线程数量
maxmcount int32// maximum number of m's allowed (or die)
nmsys int32// number of system m's not counted for deadlock
//累积空闲的 m 数量
nmfreed int64// cumulative number of freed m's
//系统 goroutine 的数量，自动更新
ngsys uint32// number of system goroutines; updated atomically
//由空闲的 p 结构体对象组成的链表
pidle puintptr // idle p's
//空闲的 p 结构体对象的数量
npidle uint32
nmspinning uint32// See "Worker thread parking/unparking" comment in proc.go.
// Global runnable queue.
//全局运行队列 G 队列
runq gQueue //这个结构体在 proc.go 里
//元素数量
runqsize int32
// disable controls selective disabling of the scheduler.
//
// Use schedEnableUser to control this.
//
// disable is protected by sched.lock.
disable struct{
// user disables scheduling of user goroutines.
user bool
runnable gQueue // pending runnable Gs
n int32// length of runnable
}
// Global cache of dead G's. 有效 dead G 全局缓存
gFree struct{
lock mutex
stack gList // Gs with stacks
noStack gList // Gs without stacks
n int32
}
// Central cache of sudog structs. dusog 结构的集中缓存
sudoglock mutex
sudogcache *sudog
// Central pool of available defer structs of different sizes. 不同大小有效的 defer 结构的池
deferlock mutex
deferpool [ 5]*_defer
// freem is the list of m's waiting to be freed when their
// m.exited is set. Linked through m.freelink.
freem *m
gcwaiting uint32// gc is waiting to run
stopwait int32
stopnote note
sysmonwait uint32
sysmonnote note
// safepointFn should be called on each P at the next GC
// safepoint if p.runSafePointFn is set.
safePointFn func(*p)
safePointWait int32
safePointNote note
profilehz int32// cpu profiling rate
procresizetime int64// nanotime of last change to gomaxprocs
totaltime int64// ∫gomaxprocs dt up to procresizetime
}
gQueue
/src/runtime/proc.go
Copytype gQueue struct{
head guintptr //队列头
tail guintptr //队列尾
}
一些重要全局变量
/src/runtime/proc.go
Copym0 m //代表主线程
g0 g //m0 绑定的 g0，也就是 M 结构体中 m0.g0=&g0
allgs []*g //保存所有的 g
/src/runtime/runtime2.go
Copyallm *m //所有的 m 构成的一个链表，包括上面的 m0
allp []*p //保存所有的 p， len(allp) == gomaxprocs
sched schedt //调度器的结构体，保存了调度器的各种信息
ncpu int32//系统 cpu 核的数量，程序启动时由 runtime 初始化
gomaxprocs int32//p 的最大数量，默认等于 ncpu，可以通过 GOMAXPROCS 修改
在程序初始化时，这些变量都会被初始化为 0 值，指针会被初始化为 nil 指针，切片初始化为 nil 切片，int 被初始化为数字 0，结构体的所有成员变量按其本类型初始化为其类型的 0 值。
调度器初始化
调度器初始化有一个主要的函数 schedinit ， 这个函数在 /src/runtime/proc.go 文件中。函数开头还把初始化的顺序给列出来了：
// The bootstrap sequence is: // // call osinit // call schedinit // make & queue new G // call runtime·mstart // // The new G calls runtime·main.
// The bootstrap sequence is: // // call osinit // call schedinit // make & queue new G // call runtime·mstart // // The new G calls runtime·main.
// raceinit must be the first call to race detector.
// In particular, it must be done before mallocinit below calls racemapshadow.
_g_ := getg //getg 在 src/runtime/stubs.go 中声明，真正的代码由编译器生成
ifraceenabled {
_g_.racectx, raceprocctx0 = raceinit
}
//设置最大 M 的数量
sched.maxmcount = 10000
tracebackinit
moduledataverify
//初始化栈空间常用管理链表
stackinit
mallocinit
//初始化当前 m
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)
// 把 p 数量从 1 调整到默认的 CPU Core 数量
procs := ncpu
ifn, ok := atoi32(gogetenv( "GOMAXPROCS")); ok && n > 0{
procs = n
}
//调整 P 数量
//这里的 P 都是新建的，所以不返回有本地任务的 p
ifprocresize(procs) != nil{
throw( "unknown runnable goroutine during bootstrap")
}
// For cgocheck > 1, we turn on the write barrier at all times
// and check all pointer writes. We can't do this until after
// procresize because the write barrier needs a P.
ifdebug.cgocheck > 1{
writeBarrier.cgo = true
writeBarrier.enabled = true
for_, p := rangeallp {
p.wbBuf.reset
}
}
ifbuildVersion == ""{
// Condition should never trigger. This code just serves
// to ensure runtime·buildVersion is kept in the resulting binary.
buildVersion = "unknown"
}
iflen(modinfo) == 1{
// Condition should never trigger. This code just serves
// to ensure runtime·modinfo is kept in the resulting binary.
modinfo = ""
}
}
开头的这个函数 getg，跳转到了 func getg *g ，定义这么一个形式，什么意思？函数首先调用 getg 函数获取当前正在运行的 g ， getg 在 src/runtime/stubs.go 中声明，真正的代码由编译器生成。
Copy // getg returns the pointer to the current g.
// The compiler rewrites calls to this function into instructions
// that fetch the g directly (from TLS or from the dedicated register).
funcgetg* g
注释里也说了，getg 返回当前正在运行的 goroutine 的指针，它会从 tls 里取出 tls[0]，也就是当前运行的 goroutine 的地址。编译器插入类似下面的代码：
Copyget_tls(CX)
MOVQ g(CX), BX; // BX 存器里面现在放的是当前 g 结构体对象的地址
原来是这么个意思。
调度器初始化大致过程：M 初始化 --> P 初始化 - -> G 初始化mcommoninit Procresize newproc-------------------------------------------------------allm 池 allp 池 g.sched 执行现场p.runq 调度队列
M/P/G 初始化：mcommoninit、procresize、newproc，他们负责 M 资源池（allm）、p 资源池（allp）、G 的运行现场（g.sched） 以及调度队列（p.runq）
调度循环
所有的工作初始化完成后，就要启动运行器了。准备工作做好了，就要启动 mstart 了。这个工作在汇编语言中也可以看出来
/src/runtime/asm_amd64.s （在 linux 下）
CopyTEXT runtime·rt0_go(SB),NOSPLIT,$ 0
... ... ...
MOVL 16(SP), AX // copy argc
MOVL AX, 0(SP)
MOVQ 24(SP), AX // copy argv
MOVQ AX, 8(SP)
CALL runtime·args(SB)
CALL runtime·osinit(SB) //OS 初始化
CALL runtime·schedinit(SB) //调度器初始化
// create a new goroutine to start program
MOVQ $runtime·mainPC(SB), AX // entry
PUSHQ AX
PUSHQ $ 0// arg size
CALL runtime·newproc(SB) // G 初始化
POPQ AX
// start this M , 启动 M
CALL runtime·mstart(SB)
CALL runtime·abort(SB) // mstart should never return
RET
转自：九卷
转自：九卷
关注我们
Linux公社
星标”
每天 获取 技术干货，让我们一起成长
合作联系：root@linuxidc.net
关注我们
Linux公社
星标”
每天 获取 技术干货，让我们一起成长
合作联系：root@linuxidc.net返回搜狐，查看更多