type g struct {
	stack struct {
		lo uintptr
		hi uintptr
	} 					// 栈内存：[stack.lo, stack.hi)
	stackguard0	uintptr //用于调度器抢占式调度
	stackguard1 uintptr

	_panic       *_panic //_panic链表头。头插法
	_defer       *_defer //_defer链表头。头插法
	m            *m				//当前 Goroutine 占用的线程，可能为空；
	sched        gobuf    //存储 Goroutine 的调度相关的数据，goroutine 的运行现场；
	stktopsp     uintptr		// 期望 sp 位于栈顶，用于回溯检查
	param        unsafe.Pointer // wakeup 唤醒时候传递的参数
	atomicstatus uint32  //Goroutine 的状态
	goid         int64 // Goroutine 的 ID，该字段对开发者不可见，Go 团队认为引入 ID 会让部分 Goroutine 变得更特殊，从而限制语言的并发能力
	preempt      bool       	// 抢占信号，stackguard0 = stackpreempt 的副本
	timer        *timer         // 为 time.Sleep 缓存的计时器

	...
}

type gobuf struct {
	sp   uintptr   //栈指针
	pc   uintptr   //程序计数器
	g    guintptr //持有 runtime.gobuf 的 Goroutine；
	ret  sys.Uintreg //系统调用的返回值
	...
}
//这些内容会在调度器保存或者恢复上下文的时候用到，其中的栈指针和程序计数器会用来存储或者恢复寄存器中的值，改变程序即将执行的代码

type m struct {
	g0   *g    // goroutine with scheduling stack
	curg *g
	...
}

type m struct {
  ...
	p             puintptr
	nextp         puintptr
	oldp          puintptr
}

type note struct {
	key uintptr
}
func notesleep(n *note) {}
func notewakeup(n *note) {}

		systemstack(func() {
			newm(sysmon, nil, -1)
		})

func newm(fn func(), _p_ *p, id int64) {
	mp := allocm(_p_, fn, id)
	mp.nextp.set(_p_)
	mp.sigmask = initSigmask
	...
	newm1(mp)
}

func newm1(mp *m) {
	if iscgo {
		...
	}
	newosproc(mp)
}

func newosproc(mp *m) {
	stk := unsafe.Pointer(mp.g0.stack.hi)
	...
	ret := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(funcPC(mstart)))
	...
}

// KillOne kills a thread
func KillOne() {
	var wg sync.WaitGroup
	wg.Add(1)

	go func() {
		defer wg.Done()
		runtime.LockOSThread()
		return
	}()

	wg.Wait()
}

// LockOSThread wires the calling goroutine to its current operating system thread.
// The calling goroutine will always execute in that thread,
// and no other goroutine will execute in it,
// until the calling goroutine has made as many calls to
// UnlockOSThread as to LockOSThread.
// If the calling goroutine exits without unlocking the thread,
// the thread will be terminated.
//
// All init functions are run on the startup thread. Calling LockOSThread
// from an init function will cause the main function to be invoked on
// that thread.
//
// A goroutine should call LockOSThread before calling OS services or
// non-Go library functions that depend on per-thread state.
func LockOSThread() {
...
}

type p struct {
	m           muintptr

	runqhead uint32
	runqtail uint32
	runq     [256]guintptr //待执行的 Goroutine 列表
	runnext guintptr       //线程下一个需要执行的 Goroutine。


	...
}

// 调度器
var sched schedt
// 保存调度器的信息
type schedt struct {
  // Global runnable queue.
	runq     gQueue
	runqsize int32
}

// The main goroutine.
func main() {
   ...
   // 执行栈最大限制：1GB（64位系统）或者 250MB（32位系统）
   if goarch.PtrSize == 8 {
      maxstacksize = 1000000000
   } else {
      maxstacksize = 250000000
   }
   
   // 1、启动系统后台监控（定期垃圾回收、抢占调度等等）
   if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon
      systemstack(func() {
         newm(sysmon, nil, -1)
      })
   }
   // 2、执行 runtime.init。运行时包中有多个 init 函数，编译器会将他们链接起来。
   //例如：1、垃圾回收器所需的参数检查 2、创建强制启动 GC 的监控 Goroutine 3、确定 defer 的运行时类型
   doInit(&runtime_inittask) // Must be before defer.

   // 3、启动垃圾回收器后台操作
   gcenable()

   // 4、执行用户态 init 函数，这意味着所有的 init 均在同一个主 Goroutine 中执行
   doInit(&main_inittask)

   // 5、执行用户 main 包中的 main 函数
   fn := main_main
   fn()
   
   //退出
   exit(0)
}

//go func() 转换成 newproc
func newproc(siz int32, fn *funcval) {
  //argp为栈上的参数起始地址
	argp := add(unsafe.Pointer(&fn), sys.PtrSize)
	gp := getg()
  //获取程序计数器pc,即newproc返回时要执行的下一条指令的地址
	pc := getcallerpc()
  //systemstack 在 runtime 中用的也比较多，其功能为让 m 切换到 g0 上执行各种调度函数
  // systemstack 的作用是切换到 g0 栈执行作为参数的函数，如果是创建main goroutine则不需要切换g0栈，因为本身runtime·rt0_go 函数本身就是在g0栈上执行的。
  // 用 g0 系统栈创建 goroutine 对象
  // newproc1传递的参数包括 fn 函数入口地址，argp 参数起始地址，siz 参数长度，调用方 pc（CALL runtime·newproc(SB)指令的下一条指令地址）
	systemstack(func() {
    //1、获取或者创建新的 Goroutine 结构体；
    //2、将传入的参数移到 Goroutine 的栈上；
    //3、更新 Goroutine 调度相关的属性；
		newg := newproc1(fn, argp, siz, gp, pc)

		_p_ := getg().m.p.ptr()
    //4、将g加入处理器的运行队列
		runqput(_p_, newg, true)
    //主go启动后，唤醒
		if mainStarted {
			wakep()
		}
	})
}

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
 // 因为已经切换到 g0 栈，所以无论什么场景都是 _g_ = g0
	_g_ := getg()
	siz := narg
	siz = (siz + 7) &^ 7
  
  // 获取g0绑定的p0
	_p_ := _g_.m.p.ptr()
  // 从 p0 的本地缓冲或者sched的g缓存里获取一个没有使用的 g，初始化时为空，返回 nil
	newg := gfget(_p_)
	if newg == nil {
    //_StackMin=2048（The minimum size of stack used by Go code）
		newg = malg(_StackMin)
		casgstatus(newg, _Gidle, _Gdead)
		allgadd(newg)
	}
	...
}

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {	
...
	totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize
	totalSize += -totalSize & (sys.SpAlign - 1)
	sp := newg.stack.hi - totalSize
	spArg := sp
	if narg > 0 {
		memmove(unsafe.Pointer(spArg), argp, uintptr(narg))
	}
	...
}

type g struct {
  。。。
	sched        gobuf    //存储 Goroutine 的调度相关的数据；
	。。。
}
type gobuf struct {
	sp   uintptr   // runtime.goexit 函数的程序计数器
  pc   uintptr   // 传入函数(go func()语句中的func())的程序计数器;pc 寄存器的作用就是存储程序接下来运行的位置
	g    guintptr //持有 runtime.gobuf 的 Goroutine；
	ret  sys.Uintreg //系统调用的返回值
	...
}
//这些内容会在调度器保存或者恢复上下文的时候用到，其中的栈指针和程序计数器会用来存储或者恢复寄存器中的值，改变程序即将执行的代码

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {	
  ...
  newg.sched.sp = sp
	newg.stktopsp = sp
  //[runtime.goexit]函数的程序计数器先赋给newg.sched.pc，之后赋给newg.sched.sp
	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)
  ...
}
func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
	sp := buf.sp
	if sys.RegSize > sys.PtrSize {
		sp -= sys.PtrSize
		*(*uintptr)(unsafe.Pointer(sp)) = 0
	}
  //sp栈顶指针向下移8字节
	sp -= sys.PtrSize
	*(*uintptr)(unsafe.Pointer(sp)) = buf.pc
  //sp 中存储了 [runtime.goexit]函数的程序计数器
	buf.sp = sp
  //传入函数(go func()语句中的func())的程序计数器;pc 寄存器的作用就是存储程序接下来运行的位置
	buf.pc = uintptr(fn)
	buf.ctxt = ctxt
}

func schedule() {
  //获取当前运行的g
	_g_ := getg()

top:
	var gp *g
	var inheritTime bool

  //查找待执行的g，如果从所有地方都获取不到，阻塞等待
	if gp == nil {
		if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
			lock(&sched.lock)
			gp = globrunqget(_g_.m.p.ptr(), 1)
			unlock(&sched.lock)
		}
	}
	if gp == nil {
		gp, inheritTime = runqget(_g_.m.p.ptr())
	}
	if gp == nil {
		gp, inheritTime = findrunnable()
	}
  ...
  //执行获取到的g
	execute(gp, inheritTime)
}

// Executed only by the owner P.
func runqget(_p_ *p) (gp *g, inheritTime bool) {
   // If there's a runnext, it's the next G to run.
   next := _p_.runnext
   if next != 0 && _p_.runnext.cas(next, 0) { //从runnext中获取
      return next.ptr(), true
   }

   for {
      h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, synchronize with other consumers
      t := _p_.runqtail
      if t == h {
         return nil, false
      }
     // 获取队列头的 g
      gp := _p_.runq[h%uint32(len(_p_.runq))].ptr()
     // 原子操作，防止这中间被其他线程因为偷工作而修改
      if atomic.CasRel(&_p_.runqhead, h, h+1) { // cas-release, commits consume
         return gp, false
      }
   }
}

func globrunqget(_p_ *p, max int32) *g {
   if sched.runqsize == 0 {
      return nil
   }

   n := sched.runqsize/gomaxprocs + 1
   if n > sched.runqsize {
      n = sched.runqsize
   }
   if max > 0 && n > max {
      n = max
   }
   if n > int32(len(_p_.runq))/2 {
      n = int32(len(_p_.runq)) / 2  //最多偷取P本地队列长度的一半
   }

   sched.runqsize -= n

   gp := sched.runq.pop()
   n--
   for ; n > 0; n-- {
      gp1 := sched.runq.pop()
      runqput(_p_, gp1, false)//// 尝试将 gp1 放入 P 本地，使全局队列得到更多的执行机会
   }
   return gp
}

//直到有活，才返回；如果没活，休眠等待被唤醒
func findrunnable() (gp *g, inheritTime bool) {
  top:
  ...
  //再次调runqget、globrunqget、netpoll找活
  ...
  gp, inheritTime, tnow, w, newWork := stealWork(now)//从其他P中偷G
  ...
  //延迟调netpoll，看看有没有活
  list := netpoll(delay) // block until new work is available
  ...
  stopm() //实在找不到活了,休眠，直到有工作需要处理时，被其他工作线程唤醒
	goto top //返回函数首
}

func execute(gp *g, inheritTime bool) {
	_g_ := getg()

	_g_.m.curg = gp
	gp.m = _g_.m
	casgstatus(gp, _Grunnable, _Grunning)
	gp.waitsince = 0
	gp.preempt = false
	gp.stackguard0 = gp.stack.lo + _StackGuard
	if !inheritTime {
		_g_.m.p.ptr().schedtick++
	}
  。。。
  //将 Goroutine 调度到当前线程上
	gogo(&gp.sched)
}

	MOVL gobuf_sp(BX), SP  // 将 runtime.goexit 函数的 PC 恢复到栈寄存器SP中
	MOVL gobuf_pc(BX), BX  // 获取待执行函数的程序计数器
	JMP  BX                // 开始执行

TEXT runtime·goexit(SB),NOSPLIT,$0-0
	CALL	runtime·goexit1(SB)

func goexit1() {
	mcall(goexit0)
}

func goexit0(gp *g) {
	_g_ := getg()

	casgstatus(gp, _Grunning, _Gdead)
	gp.m = nil
	...
	gp.param = nil
	gp.labels = nil
	gp.timer = nil

	dropg()
	gfput(_g_.m.p.ptr(), gp)
	schedule()
}

		// check if we need to force a GC
		if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && atomic.Load(&forcegc.idle) != 0 {
			lock(&forcegc.lock)
			forcegc.idle = 0
			var list gList
			list.push(forcegc.g)
			injectglist(&list)
			unlock(&forcegc.lock)
		}

// poll network if not polled for more than 10ms
if netpollinited() && lastpoll != 0 && lastpoll+10*1000*1000 < now {
   atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now))
   list := netpoll(0) // non-blocking - returns list of goroutines
      incidlelocked(-1)
      injectglist(&list)
      incidlelocked(1)
   }
}

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.
    // 为了公平，每调用 schedule 函数 61 次就要从全局可运行 goroutine 队列中获取
		if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
			lock(&sched.lock)
			gp = globrunqget(_g_.m.p.ptr(), 1)
			unlock(&sched.lock)
		}
	}
	if gp == nil {
		gp, inheritTime = runqget(_g_.m.p.ptr())
		// We can see gp != nil here even if the M is spinning,
		// if checkTimers added a local goroutine via goready.
	}
	if gp == nil {
    /*
    1、从本地运行队列、全局运行队列中查找；
    2、从网络轮询器中查找是否有 Goroutine 等待运行；
    3、通过 runtime.runqsteal 尝试从其他随机的处理器中窃取待运行的 Goroutine，该函数还可能窃取处理器的计时器；
    当前函数一定会返回一个可执行的 Goroutine，如果当前不存在就会阻塞等待
    */
		gp, inheritTime = findrunnable() // blocks until work is available
	}

func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
   if reason != waitReasonSleep {
      checkTimeouts() // timeouts may expire while two goroutines keep the scheduler busy
   }
   mp := acquirem()
   gp := mp.curg
   status := readgstatus(gp)
   if status != _Grunning && status != _Gscanrunning {
      throw("gopark: bad g status")
   }
   mp.waitlock = lock
   mp.waitunlockf = unlockf
   gp.waitreason = reason
   mp.waittraceev = traceEv
   mp.waittraceskip = traceskip
   releasem(mp)
  
   mcall(park_m) //切换到g0栈执行
}

//mcall 从当前g切换到g0栈并调用 fn(g)。 mcall 将g的当前SP、PC保存在g.sched中，以便之后可以恢复
//fn 绝对不能返回；通常它以调用 schedule 结束，让 m 运行其他 goroutine
func mcall(fn func(*g))

func park_m(gp *g) {
	_g_ := getg()
  
  //将当前 Goroutine 的状态从 `_Grunning` 切换至 `_Gwaiting`
	casgstatus(gp, _Grunning, _Gwaiting)
  //移除线程和 Goroutine 之间的关联
	dropg()
  //触发新一轮的调度
	schedule()
}

// func mcall(fn func(*g))
// Switch to m->g0's stack, call fn(g).
// Fn must never return. It should gogo(&g->sched)
// to keep running g.
TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT, $0-8
	MOVQ	AX, DX	// DX = fn

	// save state in g->sched
	MOVQ	0(SP), BX	// caller's PC
	MOVQ	BX, (g_sched+gobuf_pc)(R14)//设置g.sched.pc
	LEAQ	fn+0(FP), BX	// caller's SP
	MOVQ	BX, (g_sched+gobuf_sp)(R14)//设置g.sched.sp
  MOVQ	BP, (g_sched+gobuf_bp)(R14)//设置g.sched.bp

	// switch to m->g0 & its stack, call fn
	MOVQ	g_m(R14), BX
	MOVQ	m_g0(BX), SI	// SI = g.m.g0
	CMPQ	SI, R14	// if g == m->g0 call badmcall
	JNE	goodm
	JMP	runtime·badmcall(SB)
goodm:
	MOVQ	R14, AX		// AX (and arg 0) = g
	MOVQ	SI, R14		// g = g.m.g0
	get_tls(CX)		// Set G in TLS
	MOVQ	R14, g(CX)
	MOVQ	(g_sched+gobuf_sp)(R14), SP	// sp = g0.sched.sp
	PUSHQ	AX	// open up space for fn's arg spill slot
	MOVQ	0(DX), R12
	CALL	R12		// fn(g)
	POPQ	AX
	JMP	runtime·badmcall2(SB)
	RET

func goready(gp *g, traceskip int) {
	systemstack(func() {
		ready(gp, traceskip, true)
	})
}

func ready(gp *g, traceskip int, next bool) {
	_g_ := getg()

	casgstatus(gp, _Gwaiting, _Grunnable)
	runqput(_g_.m.p.ptr(), gp, next)
	if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 {
		wakep()
	}
}

func reentersyscall(pc, sp uintptr) {
	_g_ := getg()
	_g_.m.locks++
	_g_.stackguard0 = stackPreempt
	_g_.throwsplit = true

	save(pc, sp)
	_g_.syscallsp = sp
	_g_.syscallpc = pc //保存当前的程序计数器 PC 和栈指针 SP 中的内容
	casgstatus(_g_, _Grunning, _Gsyscall)//g状态_Grunning->_Gsyscall
	_g_.m.syscalltick = _g_.m.p.ptr().syscalltick
	_g_.m.mcache = nil
	pp := _g_.m.p.ptr()
	pp.m = 0
	_g_.m.oldp.set(pp)
	_g_.m.p = 0
	atomic.Store(&pp.status, _Psyscall)//更新处理器的状态到 _Psyscall
	if sched.gcwaiting != 0 {
		systemstack(entersyscall_gcwait)
		save(pc, sp)
	}
	_g_.m.locks--
}

func exitsyscall() {
	_g_ := getg()

	oldp := _g_.m.oldp.ptr()
	_g_.m.oldp = 0
	if exitsyscallfast(oldp) {
		_g_.m.p.ptr().syscalltick++
		casgstatus(_g_, _Gsyscall, _Grunning)
		...

		return
	}

	mcall(exitsyscall0)//切换到g0执行
	_g_.m.p.ptr().syscalltick++
	_g_.throwsplit = false
}

func exitsyscall0(gp *g) {
	casgstatus(gp, _Gsyscall, _Grunnable)//g状态_Gsyscall-->_Grunnable
	dropg()
	lock(&sched.lock)
	var _p_ *p
	if schedEnabled(gp) {
		_p_ = pidleget()
	}
	var locked bool
	if _p_ == nil {
    //将当前 Goroutine 放到全局的运行队列中，等待调度器的调度
		globrunqput(gp)
		locked = gp.lockedm != 0
	} else if atomic.Load(&sched.sysmonwait) != 0 {
		atomic.Store(&sched.sysmonwait, 0)
		notewakeup(&sched.sysmonnote)
	}
	unlock(&sched.lock)
	if _p_ != nil {
    //有空闲的p，使用空闲p处理当前 Goroutine
		acquirep(_p_)
		execute(gp, false) // Never returns.
	}
	if locked {
		stoplockedm()
		execute(gp, false) // Never returns.
	}
	stopm()
	schedule() // Never returns.
}

// Gosched 会让出当前的 P，并允许其他 Goroutine 运行。
// 它不会推迟当前的 Goroutine，因此执行会被自动恢复
func Gosched() {
	checkTimeouts()
	mcall(gosched_m)
}
/ Gosched 在 g0 上继续执行
func gosched_m(gp *g) {
	...
	goschedImpl(gp)
}

func goschedImpl(gp *g) {
	status := readgstatus(gp)
	if status&^_Gscan != _Grunning {
		dumpgstatus(gp)
		throw("bad g status")
	}
  //g的状态_Grunning-->_Grunnable
	casgstatus(gp, _Grunning, _Grunnable)
  // 使当前 m 放弃 g
	dropg()
	lock(&sched.lock)
  // 并将 g 放回全局队列中
	globrunqput(gp)
	unlock(&sched.lock)
  
  // 重新进入调度循环
	schedule()
}