Goroutine的创建

src/runtime/proc.go

  3. type funcval struct {
  4.     fn uintptr
  5.     // variable-size, fn-specific data here
  6. }
  8. //go:nosplit
  9. // siz：参数长度   fn==>fn.fn才是申明的go func(){}
  10. func newproc(siz int32, fn *funcval) {
  11.     argp := add(unsafe.Pointer(&fn), sys.PtrSize) // 将参数紧随fn.fn的地址
  12.     gp := getg() // 当前g
  13.     pc := getcallerpc() // 调用返回后的地址
  14.     systemstack(func() {
  15.         newproc1(fn, (*uint8)(argp), siz, gp, pc)
  16.     })
  17. }
  19. // fn.fn == go func(){}
  20. // argp 参数的地址
  21. // narg 参数的长度
  22. // callergp 调用者g
  23. // callerpc 调用返回后的地址
  24. func newproc1(fn *funcval, argp *uint8, narg int32, callergp *g, callerpc uintptr) {
  25.     _g_ := getg()
  27.     if fn == nil {
  28.         _g_.m.throwing = -1 // do not dump full stacks
  29.         throw("go of nil func value")
  30.     }
  31.     _g_.m.locks++ // disable preemption because it can be holding p in a local var
  32.     siz := narg
  33.     siz = (siz + 7) &^ 7  // 进行8位对齐
  35.     // 参数长度不能超过2008字节（2048-4*8-8）
  36.     if siz >= _StackMin-4*sys.RegSize-sys.RegSize {
  37.         throw("newproc: function arguments too large for new goroutine")
  38.     }
  39.     // 获取到当前g的p
  40.     _p_ := _g_.m.p.ptr()
  41.     // 从p的缓存池中去拿一个g
  42.     newg := gfget(_p_)
  43.     if newg == nil {
  44.         // 缓冲池中没有，则需要新创建一个，栈大小为2k
  45.         newg = malg(_StackMin)
  46.         casgstatus(newg, _Gidle, _Gdead)
  47.         allgadd(newg) // 新创建的g置位_Gdead状态，防止GC扫描到
  48.     }
  49.     if newg.stack.hi == 0 {
  50.         throw("newproc1: newg missing stack")
  51.     }
  53.     if readgstatus(newg) != _Gdead {
  54.         throw("newproc1: new g is not Gdead")
  55.     }
  57.     totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
  58.     totalSize += -totalSize & (sys.SpAlign - 1)                  // align to spAlign
  59.     sp := newg.stack.hi - totalSize
  60.     spArg := sp
  61.     if usesLR {
  62.         // caller's LR
  63.         *(*uintptr)(unsafe.Pointer(sp)) = 0
  64.         prepGoExitFrame(sp)
  65.         spArg += sys.MinFrameSize
  66.     }
  67.     if narg > 0 {
  68.         memmove(unsafe.Pointer(spArg), unsafe.Pointer(argp), uintptr(narg))
  69.         // This is a stack-to-stack copy. If write barriers
  70.         // are enabled and the source stack is grey (the
  71.         // destination is always black), then perform a
  72.         // barrier copy. We do this *after* the memmove
  73.         // because the destination stack may have garbage on
  74.         // it.
  75.         if writeBarrier.needed && !_g_.m.curg.gcscandone {
  76.             f := findfunc(fn.fn)
  77.             stkmap := (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps))
  78.             if stkmap.nbit > 0 {
  79.                 // We're in the prologue, so it's always stack map index 0.
  80.                 bv := stackmapdata(stkmap, 0)
  81.                 bulkBarrierBitmap(spArg, spArg, uintptr(bv.n)*sys.PtrSize, 0, bv.bytedata)
  82.             }
  83.         }
  84.     }
  85.     memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
  86.     newg.sched.sp = sp // 保存栈顶
  87.     newg.stktopsp = sp
  88.     newg.sched.pc = funcPC(goexit) + sys.PCQuantum // 这里需要结合gostartcallfn去了解
  89.     newg.sched.g = guintptr(unsafe.Pointer(newg))
  90.     gostartcallfn(&newg.sched, fn)
  91.     newg.gopc = callerpc
  92.     newg.ancestors = saveAncestors(callergp)
  93.     newg.startpc = fn.fn
  94.     if _g_.m.curg != nil {
  95.         newg.labels = _g_.m.curg.labels
  96.     }
  97.     if isSystemGoroutine(newg, false) {
  98.         atomic.Xadd(&sched.ngsys, +1)
  99.     }
  100.     newg.gcscanvalid = false
  101.     casgstatus(newg, _Gdead, _Grunnable)
  103.     if _p_.goidcache == _p_.goidcacheend {
  104.         // Sched.goidgen is the last allocated id,
  105.         // this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
  106.         // At startup sched.goidgen=0, so main goroutine receives goid=1.
  107.         _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
  108.         _p_.goidcache -= _GoidCacheBatch - 1
  109.         _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
  110.     }
  111.     newg.goid = int64(_p_.goidcache)
  112.     _p_.goidcache++
  114.     runqput(_p_, newg, true)
  116.     // 有空闲的p存在，并且处于自旋状态的m数量为0，而且在主函数已经运行的情况下
  117.     // 尝试去唤醒某个m
  118.     if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 && mainStarted {
  119.         wakep()
  120.     }
  121.     _g_.m.locks--
  122.     if _g_.m.locks == 0 && _g_.preempt { // restore the preemption request in case we've cleared it in newstack
  123.         _g_.stackguard0 = stackPreempt
  124.     }
  125. }
  127. func gostartcallfn(gobuf *gobuf, fv *funcval) {
  128.     var fn unsafe.Pointer
  129.     if fv != nil {
  130.         fn = unsafe.Pointer(fv.fn)// fv.fn: gorotine的入口地址
  131.     } else {
  132.         fn = unsafe.Pointer(funcPC(nilfunc))
  133.     }
  134.     gostartcall(gobuf, fn, unsafe.Pointer(fv))
  135. }
  137. func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
  138.     sp := buf.sp
  139.     if sys.RegSize > sys.PtrSize {
  140.         sp -= sys.PtrSize
  141.         *(*uintptr)(unsafe.Pointer(sp)) = 0
  142.     }
  143.     sp -= sys.PtrSize // 栈顶往下移动8位，为返回地址预留空间
  144.     // 将fn伪装成是函数goexit函数调用的，函数fn执行完成返回到goexit继续执行，完成清理操作
  145.     *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
  146.     buf.sp = sp
  147.      //这里才真正让newg的ip寄存器指向fn函数，注意，这里只是在设置newg的一些信息，newg还未执行，
  148.      //等到newg被调度起来运行时，调度器会把buf.pc放入cpu的IP寄存器，
  149.      //从而使newg得以在cpu上真正的运行起来
  150.     buf.pc = uintptr(fn)
  151.     buf.ctxt = ctxt
  152. }

参考

https://mp.weixin.qq.com/s/8OffE6xDj4fD1q-aJw43ig
http://xiaorui.cc/archives/6483