协程 goroutine

func schedinit() {
  gp := getg()
  ...
  sched.maxmcount = 10000

  // The world starts stopped.
  worldStopped()

  moduledataverify()
  stackinit()
  mallocinit()
  godebug := getGodebugEarly()
  initPageTrace(godebug) // must run after mallocinit but before anything allocates
  cpuinit(godebug)       // must run before alginit
  alginit()              // maps, hash, fastrand must not be used before this call
  fastrandinit()         // must run before mcommoninit
  mcommoninit(gp.m, -1)
  modulesinit()   // provides activeModules
  typelinksinit() // uses maps, activeModules
  itabsinit()     // uses activeModules
  stkobjinit()    // must run before GC starts

  sigsave(&gp.m.sigmask)
  initSigmask = gp.m.sigmask

  goargs()
  goenvs()
  parsedebugvars()
  gcinit()

  lock(&sched.lock)
  sched.lastpoll.Store(nanotime())
  procs := ncpu
  if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
    procs = n
  }
  if procresize(procs) != nil {
    throw("unknown runnable goroutine during bootstrap")
  }
  unlock(&sched.lock)

  // World is effectively started now, as P's can run.
  worldStarted()
  ...
}

// Create a new g running fn.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.
func newproc(fn *funcval) {
  gp := getg()
  pc := getcallerpc()
  systemstack(func() {
    newg := newproc1(fn, gp, pc)

    pp := getg().m.p.ptr()
    runqput(pp, newg, true)

    if mainStarted {
      wakep()
    }
  })
}

// Create a new g in state _Grunnable, starting at fn. callerpc is the
// address of the go statement that created this. The caller is responsible
// for adding the new g to the scheduler.
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
  if fn == nil {
    fatal("go of nil func value")
  }

  mp := acquirem() // disable preemption because we hold M and P in local vars.
  pp := mp.p.ptr()
  newg := gfget(pp)
  if newg == nil {
    newg = malg(stackMin)
    casgstatus(newg, _Gidle, _Gdead)
    allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
  }
  if newg.stack.hi == 0 {
    throw("newproc1: newg missing stack")
  }

  if readgstatus(newg) != _Gdead {
    throw("newproc1: new g is not Gdead")
  }

  totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) // extra space in case of reads slightly beyond frame
  totalSize = alignUp(totalSize, sys.StackAlign)
  sp := newg.stack.hi - totalSize
  spArg := sp
  if usesLR {
    // caller's LR
    *(*uintptr)(unsafe.Pointer(sp)) = 0
    prepGoExitFrame(sp)
    spArg += sys.MinFrameSize
  }

  memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
  newg.sched.sp = sp
  newg.stktopsp = sp
  newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
  newg.sched.g = guintptr(unsafe.Pointer(newg))
  gostartcallfn(&newg.sched, fn)
  newg.parentGoid = callergp.goid
  newg.gopc = callerpc
  newg.ancestors = saveAncestors(callergp)
  newg.startpc = fn.fn
  if isSystemGoroutine(newg, false) {
    sched.ngsys.Add(1)
  } else {
    // Only user goroutines inherit pprof labels.
    if mp.curg != nil {
      newg.labels = mp.curg.labels
    }
    if goroutineProfile.active {
      // A concurrent goroutine profile is running. It should include
      // exactly the set of goroutines that were alive when the goroutine
      // profiler first stopped the world. That does not include newg, so
      // mark it as not needing a profile before transitioning it from
      // _Gdead.
      newg.goroutineProfiled.Store(goroutineProfileSatisfied)
    }
  }
  // Track initial transition?
  newg.trackingSeq = uint8(fastrand())
  if newg.trackingSeq%gTrackingPeriod == 0 {
    newg.tracking = true
  }
  casgstatus(newg, _Gdead, _Grunnable)
  gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))

  if pp.goidcache == pp.goidcacheend {
    // Sched.goidgen is the last allocated id,
    // this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
    // At startup sched.goidgen=0, so main goroutine receives goid=1.
    pp.goidcache = sched.goidgen.Add(_GoidCacheBatch)
    pp.goidcache -= _GoidCacheBatch - 1
    pp.goidcacheend = pp.goidcache + _GoidCacheBatch
  }
  newg.goid = pp.goidcache
  pp.goidcache++
  if raceenabled {
    newg.racectx = racegostart(callerpc)
    newg.raceignore = 0
    if newg.labels != nil {
      // See note in proflabel.go on labelSync's role in synchronizing
      // with the reads in the signal handler.
      racereleasemergeg(newg, unsafe.Pointer(&labelSync))
    }
  }
  if traceEnabled() {
    traceGoCreate(newg, newg.startpc)
  }
  releasem(mp)

  return newg
}

// Allocate a new g, with a stack big enough for stacksize bytes.
func malg(stacksize int32) *g {
  newg := new(g)
  if stacksize >= 0 {
    stacksize = round2(_StackSystem + stacksize)
    systemstack(func() {
      newg.stack = stackalloc(uint32(stacksize))
    })
    newg.stackguard0 = newg.stack.lo + _StackGuard
    newg.stackguard1 = ^uintptr(0)
    // Clear the bottom word of the stack. We record g
    // there on gsignal stack during VDSO on ARM and ARM64.
    *(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
  }
  return newg
}

func allgadd(gp *g) {
  if readgstatus(gp) == _Gidle {
    throw("allgadd: bad status Gidle")
  }

  lock(&allglock)
  allgs = append(allgs, gp)
  if &allgs[0] != allgptr {
    atomicstorep(unsafe.Pointer(&allgptr), unsafe.Pointer(&allgs[0]))
  }
  atomic.Storeuintptr(&allglen, uintptr(len(allgs)))
  unlock(&allglock)
}

totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) // extra space in case of reads slightly beyond frame
totalSize = alignUp(totalSize, sys.StackAlign)
sp := newg.stack.hi - totalSize
spArg := sp
if usesLR {
  // caller's LR
  *(*uintptr)(unsafe.Pointer(sp)) = 0
  prepGoExitFrame(sp)
  spArg += sys.MinFrameSize
}

memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
newg.sched.sp = sp
newg.stktopsp = sp
newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
newg.sched.g = guintptr(unsafe.Pointer(newg))
gostartcallfn(&newg.sched, fn)
newg.parentGoid = callergp.goid
newg.gopc = callerpc
newg.ancestors = saveAncestors(callergp)
newg.startpc = fn.fn

// adjust Gobuf as if it executed a call to fn
// and then stopped before the first instruction in fn.
func gostartcallfn(gobuf *gobuf, fv *funcval) {
  var fn unsafe.Pointer
  if fv != nil {
    fn = unsafe.Pointer(fv.fn)
  } else {
    fn = unsafe.Pointer(abi.FuncPCABIInternal(nilfunc))
  }
  gostartcall(gobuf, fn, unsafe.Pointer(fv))
}

// adjust Gobuf as if it executed a call to fn with context ctxt
// and then stopped before the first instruction in fn.
func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
  sp := buf.sp
  sp -= goarch.PtrSize
  *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
  buf.sp = sp
  buf.pc = uintptr(fn)
  buf.ctxt = ctxt
}

// Get from gfree list.
// If local list is empty, grab a batch from global list.
func gfget(pp *p) *g {
retry:
  if pp.gFree.empty() && (!sched.gFree.stack.empty() || !sched.gFree.noStack.empty()) {
    lock(&sched.gFree.lock)
    // Move a batch of free Gs to the P.
    for pp.gFree.n < 32 {
      // Prefer Gs with stacks.
      gp := sched.gFree.stack.pop()
      if gp == nil {
        gp = sched.gFree.noStack.pop()
        if gp == nil {
          break
        }
      }
      sched.gFree.n--
      pp.gFree.push(gp)
      pp.gFree.n++
    }
    unlock(&sched.gFree.lock)
    goto retry
  }
  gp := pp.gFree.pop()
  if gp == nil {
    return nil
  }
  pp.gFree.n--
  if gp.stack.lo != 0 && gp.stack.hi-gp.stack.lo != uintptr(startingStackSize) {
    // Deallocate old stack. We kept it in gfput because it was the
    // right size when the goroutine was put on the free list, but
    // the right size has changed since then.
    systemstack(func() {
      stackfree(gp.stack)
      gp.stack.lo = 0
      gp.stack.hi = 0
      gp.stackguard0 = 0
    })
  }
  if gp.stack.lo == 0 {
    // Stack was deallocated in gfput or just above. Allocate a new one.
    systemstack(func() {
      gp.stack = stackalloc(startingStackSize)
    })
    gp.stackguard0 = gp.stack.lo + _StackGuard
  } else {
    if raceenabled {
      racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
    }
    if msanenabled {
      msanmalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
    }
    if asanenabled {
      asanunpoison(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
    }
  }
  return gp
}

// runqput tries to put g on the local runnable queue.
// If next is false, runqput adds g to the tail of the runnable queue.
// If next is true, runqput puts g in the pp.runnext slot.
// If the run queue is full, runnext puts g on the global queue.
// Executed only by the owner P.
func runqput(pp *p, gp *g, next bool) {
  if randomizeScheduler && next && fastrandn(2) == 0 {
    next = false
  }

  if next {
  retryNext:
    oldnext := pp.runnext
    if !pp.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
      goto retryNext
    }
    if oldnext == 0 {
      return
    }
    // Kick the old runnext out to the regular run queue.
    gp = oldnext.ptr()
  }

retry:
  h := atomic.LoadAcq(&pp.runqhead) // load-acquire, synchronize with consumers
  t := pp.runqtail
  if t-h < uint32(len(pp.runq)) {
    pp.runq[t%uint32(len(pp.runq))].set(gp)
    atomic.StoreRel(&pp.runqtail, t+1) // store-release, makes the item available for consumption
    return
  }
  if runqputslow(pp, gp, h, t) {
    return
  }
  // the queue is not full, now the put above must succeed
  goto retry
}

// Put g and a batch of work from local runnable queue on global queue.
// Executed only by the owner P.
func runqputslow(pp *p, gp *g, h, t uint32) bool {
  var batch [len(pp.runq)/2 + 1]*g

  // First, grab a batch from local queue.
  n := t - h
  n = n / 2
  if n != uint32(len(pp.runq)/2) {
    throw("runqputslow: queue is not full")
  }
  for i := uint32(0); i < n; i++ {
    batch[i] = pp.runq[(h+i)%uint32(len(pp.runq))].ptr()
  }
  if !atomic.CasRel(&pp.runqhead, h, h+n) { // cas-release, commits consume
    return false
  }
  batch[n] = gp

  if randomizeScheduler {
    for i := uint32(1); i <= n; i++ {
      j := fastrandn(i + 1)
      batch[i], batch[j] = batch[j], batch[i]
    }
  }

  // Link the goroutines.
  for i := uint32(0); i < n; i++ {
    batch[i].schedlink.set(batch[i+1])
  }
  var q gQueue
  q.head.set(batch[0])
  q.tail.set(batch[n])

  // Now put the batch on global queue.
  lock(&sched.lock)
  globrunqputbatch(&q, int32(n+1))
  unlock(&sched.lock)
  return true
}

func globrunqputbatch(batch *gQueue, n int32) {
  assertLockHeld(&sched.lock)

  sched.runq.pushBackAll(*batch)
  sched.runqsize += n
  *batch = gQueue{}
}

// mstart0 is the Go entry-point for new Ms.
// This must not split the stack because we may not even have stack
// bounds set up yet.
//
// May run during STW (because it doesn't have a P yet), so write
// barriers are not allowed.
//
//go:nosplit
//go:nowritebarrierrec
func mstart0() {
  gp := getg()

  osStack := gp.stack.lo == 0
  if osStack {
    // Initialize stack bounds from system stack.
    // Cgo may have left stack size in stack.hi.
    // minit may update the stack bounds.
    //
    // Note: these bounds may not be very accurate.
    // We set hi to &size, but there are things above
    // it. The 1024 is supposed to compensate this,
    // but is somewhat arbitrary.
    size := gp.stack.hi
    if size == 0 {
      size = 8192 * sys.StackGuardMultiplier
    }
    gp.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
    gp.stack.lo = gp.stack.hi - size + 1024
  }
  // Initialize stack guard so that we can start calling regular
  // Go code.
  gp.stackguard0 = gp.stack.lo + _StackGuard
  // This is the g0, so we can also call go:systemstack
  // functions, which check stackguard1.
  gp.stackguard1 = gp.stackguard0
  mstart1()

  // Exit this thread.
  if mStackIsSystemAllocated() {
    // Windows, Solaris, illumos, Darwin, AIX and Plan 9 always system-allocate
    // the stack, but put it in gp.stack before mstart,
    // so the logic above hasn't set osStack yet.
    osStack = true
  }
  mexit(osStack)
}

// The go:noinline is to guarantee the getcallerpc/getcallersp below are safe,
// so that we can set up g0.sched to return to the call of mstart1 above.
//
//go:noinline
func mstart1() {
  gp := getg()

  if gp != gp.m.g0 {
    throw("bad runtime·mstart")
  }

  // Set up m.g0.sched as a label returning to just
  // after the mstart1 call in mstart0 above, for use by goexit0 and mcall.
  // We're never coming back to mstart1 after we call schedule,
  // so other calls can reuse the current frame.
  // And goexit0 does a gogo that needs to return from mstart1
  // and let mstart0 exit the thread.
  gp.sched.g = guintptr(unsafe.Pointer(gp))
  gp.sched.pc = getcallerpc()
  gp.sched.sp = getcallersp()

  asminit()
  minit()

  // Install signal handlers; after minit so that minit can
  // prepare the thread to be able to handle the signals.
  if gp.m == &m0 {
    mstartm0()
  }

  if fn := gp.m.mstartfn; fn != nil {
    fn()
  }

  if gp.m != &m0 {
    acquirep(gp.m.nextp.ptr())
    gp.m.nextp = 0
  }
  schedule()
}

/ One round of scheduler: find a runnable goroutine and execute it.
// Never returns.
func schedule() {
  mp := getg().m

  if mp.locks != 0 {
    throw("schedule: holding locks")
  }

  if mp.lockedg != 0 {
    stoplockedm()
    execute(mp.lockedg.ptr(), false) // Never returns.
  }

  // We should not schedule away from a g that is executing a cgo call,
  // since the cgo call is using the m's g0 stack.
  if mp.incgo {
    throw("schedule: in cgo")
  }

top:
  pp := mp.p.ptr()
  pp.preempt = false

  // Safety check: if we are spinning, the run queue should be empty.
  // Check this before calling checkTimers, as that might call
  // goready to put a ready goroutine on the local run queue.
  if mp.spinning && (pp.runnext != 0 || pp.runqhead != pp.runqtail) {
    throw("schedule: spinning with local work")
  }

  gp, inheritTime, tryWakeP := findRunnable() // blocks until work is available

  // This thread is going to run a goroutine and is not spinning anymore,
  // so if it was marked as spinning we need to reset it now and potentially
  // start a new spinning M.
  if mp.spinning {
    resetspinning()
  }

  if sched.disable.user && !schedEnabled(gp) {
    // Scheduling of this goroutine is disabled. Put it on
    // the list of pending runnable goroutines for when we
    // re-enable user scheduling and look again.
    lock(&sched.lock)
    if schedEnabled(gp) {
      // Something re-enabled scheduling while we
      // were acquiring the lock.
      unlock(&sched.lock)
    } else {
      sched.disable.runnable.pushBack(gp)
      sched.disable.n++
      unlock(&sched.lock)
      goto top
    }
  }

  // If about to schedule a not-normal goroutine (a GCworker or tracereader),
  // wake a P if there is one.
  if tryWakeP {
    wakep()
  }
  if gp.lockedm != 0 {
    // Hands off own p to the locked m,
    // then blocks waiting for a new p.
    startlockedm(gp)
    goto top
  }

  execute(gp, inheritTime)
}

mp := getg().m

if mp.locks != 0 {
  throw("schedule: holding locks")
}

if mp.lockedg != 0 {
  stoplockedm()
  execute(mp.lockedg.ptr(), false) // Never returns.
}

// We should not schedule away from a g that is executing a cgo call,
// since the cgo call is using the m's g0 stack.
if mp.incgo {
  throw("schedule: in cgo")
}

func schedule() {
  ...

top:
  pp := mp.p.ptr()
  pp.preempt = false

  if mp.spinning && (pp.runnext != 0 || pp.runqhead != pp.runqtail) {
    throw("schedule: spinning with local work")
  }

  gp, inheritTime, tryWakeP := findRunnable()

  if mp.spinning {
    resetspinning()
  }

  if sched.disable.user && !schedEnabled(gp) {
    lock(&sched.lock)
    if schedEnabled(gp) {
      unlock(&sched.lock)
    } else {
      sched.disable.runnable.pushBack(gp)
      sched.disable.n++
      unlock(&sched.lock)
      goto top
    }
  }

  if gp.lockedm != 0 {
    startlockedm(gp)
    goto top
  }

  execute(gp, inheritTime)
}

// Tries to add one more P to execute G's.
// Called when a G is made runnable (newproc, ready).
// Must be called with a P.
func wakep() {
  // Be conservative about spinning threads, only start one if none exist
  // already.
  if sched.nmspinning.Load() != 0 || !sched.nmspinning.CompareAndSwap(0, 1) {
    return
  }

  // Disable preemption until ownership of pp transfers to the next M in
  // startm. Otherwise preemption here would leave pp stuck waiting to
  // enter _Pgcstop.
  //
  // See preemption comment on acquirem in startm for more details.
  mp := acquirem()

  var pp *p
  lock(&sched.lock)
  pp, _ = pidlegetSpinning(0)
  if pp == nil {
    if sched.nmspinning.Add(-1) < 0 {
      throw("wakep: negative nmspinning")
    }
    unlock(&sched.lock)
    releasem(mp)
    return
  }
  // Since we always have a P, the race in the "No M is available"
  // comment in startm doesn't apply during the small window between the
  // unlock here and lock in startm. A checkdead in between will always
  // see at least one running M (ours).
  unlock(&sched.lock)

  startm(pp, true, false)

  releasem(mp)
}

// Schedules the locked m to run the locked gp.
// May run during STW, so write barriers are not allowed.
//
//go:nowritebarrierrec
func startlockedm(gp *g) {
  mp := gp.lockedm.ptr()
  if mp == getg().m {
    throw("startlockedm: locked to me")
  }
  if mp.nextp != 0 {
    throw("startlockedm: m has p")
  }
  // directly handoff current P to the locked m
  incidlelocked(-1)
  pp := releasep()
  mp.nextp.set(pp)
  notewakeup(&mp.park)
  stopm()
}

// Schedules gp to run on the current M.
// If inheritTime is true, gp inherits the remaining time in the
// current time slice. Otherwise, it starts a new time slice.
// Never returns.
//
// Write barriers are allowed because this is called immediately after
// acquiring a P in several places.
//
//go:yeswritebarrierrec
func execute(gp *g, inheritTime bool) {
  mp := getg().m

  if goroutineProfile.active {
    // Make sure that gp has had its stack written out to the goroutine
    // profile, exactly as it was when the goroutine profiler first stopped
    // the world.
    tryRecordGoroutineProfile(gp, osyield)
  }

  // Assign gp.m before entering _Grunning so running Gs have an
  // M.
  mp.curg = gp
  gp.m = mp
  casgstatus(gp, _Grunnable, _Grunning)
  gp.waitsince = 0
  gp.preempt = false
  gp.stackguard0 = gp.stack.lo + _StackGuard
  if !inheritTime {
    mp.p.ptr().schedtick++
  }

  // Check whether the profiler needs to be turned on or off.
  hz := sched.profilehz
  if mp.profilehz != hz {
    setThreadCPUProfiler(hz)
  }

  if trace.enabled {
    // GoSysExit has to happen when we have a P, but before GoStart.
    // So we emit it here.
    if gp.syscallsp != 0 && gp.sysblocktraced {
      traceGoSysExit(gp.sysexitticks)
    }
    traceGoStart()
  }

  gogo(&gp.sched)
}

// Finds a runnable goroutine to execute.
// Tries to steal from other P's, get g from local or global queue, poll network.
// tryWakeP indicates that the returned goroutine is not normal (GC worker, trace
// reader) so the caller should try to wake a P.
func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
  mp := getg().m

  // The conditions here and in handoffp must agree: if
  // findrunnable would return a G to run, handoffp must start
  // an M.

top:
  pp := mp.p.ptr()
  if sched.gcwaiting.Load() {
    gcstopm()
    goto top
  }
  if pp.runSafePointFn != 0 {
    runSafePointFn()
  }

  // now and pollUntil are saved for work stealing later,
  // which may steal timers. It's important that between now
  // and then, nothing blocks, so these numbers remain mostly
  // relevant.
  now, pollUntil, _ := checkTimers(pp, 0)

  // Try to schedule the trace reader.
  if trace.enabled || trace.shutdown {
    gp := traceReader()
    if gp != nil {
      casgstatus(gp, _Gwaiting, _Grunnable)
      traceGoUnpark(gp, 0)
      return gp, false, true
    }
  }

  // Try to schedule a GC worker.
  if gcBlackenEnabled != 0 {
    gp, tnow := gcController.findRunnableGCWorker(pp, now)
    if gp != nil {
      return gp, false, true
    }
    now = tnow
  }

  // 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.
  if pp.schedtick%61 == 0 && sched.runqsize > 0 {
    lock(&sched.lock)
    gp := globrunqget(pp, 1)
    unlock(&sched.lock)
    if gp != nil {
      return gp, false, false
    }
  }

  // Wake up the finalizer G.
  if fingStatus.Load()&(fingWait|fingWake) == fingWait|fingWake {
    if gp := wakefing(); gp != nil {
      ready(gp, 0, true)
    }
  }
  if *cgo_yield != nil {
    asmcgocall(*cgo_yield, nil)
  }

  // local runq
  if gp, inheritTime := runqget(pp); gp != nil {
    return gp, inheritTime, false
  }

  // global runq
  if sched.runqsize != 0 {
    lock(&sched.lock)
    gp := globrunqget(pp, 0)
    unlock(&sched.lock)
    if gp != nil {
      return gp, false, false
    }
  }

  // Poll network.
  // This netpoll is only an optimization before we resort to stealing.
  // We can safely skip it if there are no waiters or a thread is blocked
  // in netpoll already. If there is any kind of logical race with that
  // blocked thread (e.g. it has already returned from netpoll, but does
  // not set lastpoll yet), this thread will do blocking netpoll below
  // anyway.
  if netpollinited() && netpollWaiters.Load() > 0 && sched.lastpoll.Load() != 0 {
    if list := netpoll(0); !list.empty() { // non-blocking
      gp := list.pop()
      injectglist(&list)
      casgstatus(gp, _Gwaiting, _Grunnable)
      if trace.enabled {
        traceGoUnpark(gp, 0)
      }
      return gp, false, false
    }
  }

  // Spinning Ms: steal work from other Ps.
  //
  // Limit the number of spinning Ms to half the number of busy Ps.
  // This is necessary to prevent excessive CPU consumption when
  // GOMAXPROCS>>1 but the program parallelism is low.
  if mp.spinning || 2*sched.nmspinning.Load() < gomaxprocs-sched.npidle.Load() {
    if !mp.spinning {
      mp.becomeSpinning()
    }

    gp, inheritTime, tnow, w, newWork := stealWork(now)
    if gp != nil {
      // Successfully stole.
      return gp, inheritTime, false
    }
    if newWork {
      // There may be new timer or GC work; restart to
      // discover.
      goto top
    }

    now = tnow
    if w != 0 && (pollUntil == 0 || w < pollUntil) {
      // Earlier timer to wait for.
      pollUntil = w
    }
  }

  // We have nothing to do.
  //
  // If we're in the GC mark phase, can safely scan and blacken objects,
  // and have work to do, run idle-time marking rather than give up the P.
  if gcBlackenEnabled != 0 && gcMarkWorkAvailable(pp) && gcController.addIdleMarkWorker() {
    node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
    if node != nil {
      pp.gcMarkWorkerMode = gcMarkWorkerIdleMode
      gp := node.gp.ptr()
      casgstatus(gp, _Gwaiting, _Grunnable)
      if trace.enabled {
        traceGoUnpark(gp, 0)
      }
      return gp, false, false
    }
    gcController.removeIdleMarkWorker()
  }

  // wasm only:
  // If a callback returned and no other goroutine is awake,
  // then wake event handler goroutine which pauses execution
  // until a callback was triggered.
  gp, otherReady := beforeIdle(now, pollUntil)
  if gp != nil {
    casgstatus(gp, _Gwaiting, _Grunnable)
    if trace.enabled {
      traceGoUnpark(gp, 0)
    }
    return gp, false, false
  }
  if otherReady {
    goto top
  }

  // Before we drop our P, make a snapshot of the allp slice,
  // which can change underfoot once we no longer block
  // safe-points. We don't need to snapshot the contents because
  // everything up to cap(allp) is immutable.
  allpSnapshot := allp
  // Also snapshot masks. Value changes are OK, but we can't allow
  // len to change out from under us.
  idlepMaskSnapshot := idlepMask
  timerpMaskSnapshot := timerpMask

  // return P and block
  lock(&sched.lock)
  if sched.gcwaiting.Load() || pp.runSafePointFn != 0 {
    unlock(&sched.lock)
    goto top
  }
  if sched.runqsize != 0 {
    gp := globrunqget(pp, 0)
    unlock(&sched.lock)
    return gp, false, false
  }
  if !mp.spinning && sched.needspinning.Load() == 1 {
    // See "Delicate dance" comment below.
    mp.becomeSpinning()
    unlock(&sched.lock)
    goto top
  }
  if releasep() != pp {
    throw("findrunnable: wrong p")
  }
  now = pidleput(pp, now)
  unlock(&sched.lock)

  // Delicate dance: thread transitions from spinning to non-spinning
  // state, potentially concurrently with submission of new work. We must
  // drop nmspinning first and then check all sources again (with
  // #StoreLoad memory barrier in between). If we do it the other way
  // around, another thread can submit work after we've checked all
  // sources but before we drop nmspinning; as a result nobody will
  // unpark a thread to run the work.
  //
  // This applies to the following sources of work:
  //
  // * Goroutines added to a per-P run queue.
  // * New/modified-earlier timers on a per-P timer heap.
  // * Idle-priority GC work (barring golang.org/issue/19112).
  //
  // If we discover new work below, we need to restore m.spinning as a
  // signal for resetspinning to unpark a new worker thread (because
  // there can be more than one starving goroutine).
  //
  // However, if after discovering new work we also observe no idle Ps
  // (either here or in resetspinning), we have a problem. We may be
  // racing with a non-spinning M in the block above, having found no
  // work and preparing to release its P and park. Allowing that P to go
  // idle will result in loss of work conservation (idle P while there is
  // runnable work). This could result in complete deadlock in the
  // unlikely event that we discover new work (from netpoll) right as we
  // are racing with _all_ other Ps going idle.
  //
  // We use sched.needspinning to synchronize with non-spinning Ms going
  // idle. If needspinning is set when they are about to drop their P,
  // they abort the drop and instead become a new spinning M on our
  // behalf. If we are not racing and the system is truly fully loaded
  // then no spinning threads are required, and the next thread to
  // naturally become spinning will clear the flag.
  //
  // Also see "Worker thread parking/unparking" comment at the top of the
  // file.
  wasSpinning := mp.spinning
  if mp.spinning {
    mp.spinning = false
    if sched.nmspinning.Add(-1) < 0 {
      throw("findrunnable: negative nmspinning")
    }

    // Note the for correctness, only the last M transitioning from
    // spinning to non-spinning must perform these rechecks to
    // ensure no missed work. However, the runtime has some cases
    // of transient increments of nmspinning that are decremented
    // without going through this path, so we must be conservative
    // and perform the check on all spinning Ms.
    //
    // See https://go.dev/issue/43997.

    // Check all runqueues once again.
    pp := checkRunqsNoP(allpSnapshot, idlepMaskSnapshot)
    if pp != nil {
      acquirep(pp)
      mp.becomeSpinning()
      goto top
    }

    // Check for idle-priority GC work again.
    pp, gp := checkIdleGCNoP()
    if pp != nil {
      acquirep(pp)
      mp.becomeSpinning()

      // Run the idle worker.
      pp.gcMarkWorkerMode = gcMarkWorkerIdleMode
      casgstatus(gp, _Gwaiting, _Grunnable)
      if trace.enabled {
        traceGoUnpark(gp, 0)
      }
      return gp, false, false
    }

    // Finally, check for timer creation or expiry concurrently with
    // transitioning from spinning to non-spinning.
    //
    // Note that we cannot use checkTimers here because it calls
    // adjusttimers which may need to allocate memory, and that isn't
    // allowed when we don't have an active P.
    pollUntil = checkTimersNoP(allpSnapshot, timerpMaskSnapshot, pollUntil)
  }

  // Poll network until next timer.
  if netpollinited() && (netpollWaiters.Load() > 0 || pollUntil != 0) && sched.lastpoll.Swap(0) != 0 {
    sched.pollUntil.Store(pollUntil)
    if mp.p != 0 {
      throw("findrunnable: netpoll with p")
    }
    if mp.spinning {
      throw("findrunnable: netpoll with spinning")
    }
    // Refresh now.
    now = nanotime()
    delay := int64(-1)
    if pollUntil != 0 {
      delay = pollUntil - now
      if delay < 0 {
        delay = 0
      }
    }
    if faketime != 0 {
      // When using fake time, just poll.
      delay = 0
    }
    list := netpoll(delay) // block until new work is available
    sched.pollUntil.Store(0)
    sched.lastpoll.Store(now)
    if faketime != 0 && list.empty() {
      // Using fake time and nothing is ready; stop M.
      // When all M's stop, checkdead will call timejump.
      stopm()
      goto top
    }
    lock(&sched.lock)
    pp, _ := pidleget(now)
    unlock(&sched.lock)
    if pp == nil {
      injectglist(&list)
    } else {
      acquirep(pp)
      if !list.empty() {
        gp := list.pop()
        injectglist(&list)
        casgstatus(gp, _Gwaiting, _Grunnable)
        if trace.enabled {
          traceGoUnpark(gp, 0)
        }
        return gp, false, false
      }
      if wasSpinning {
        mp.becomeSpinning()
      }
      goto top
    }
  } else if pollUntil != 0 && netpollinited() {
    pollerPollUntil := sched.pollUntil.Load()
    if pollerPollUntil == 0 || pollerPollUntil > pollUntil {
      netpollBreak()
    }
  }
  stopm()
  goto top
}