HikariTish

1
type g struct {
2
  // Stack parameters.
3
  stack       stack   // 描述当前栈的范围 [stack.lo, stack.hi)
4
  stackguard0 uintptr // 用于栈溢出检测，通常 stack.lo + StackGuard
5
  stackguard1 uintptr // 用于 C 代码中的栈溢出检测
6

7
  _panic       *_panic // 最内层的 panic
8
  _defer       *_defer // 最内层的 defer
9

10
  m            *m       // 当前绑定的 M；可能临时为空（如阻塞时）
11
  sched        gobuf    // 保存调度上下文
12
  syscallsp    uintptr  // 系统调用时的 SP（如果需要）
13
  syscallpc    uintptr  // 系统调用时的 PC
14
  stktopsp    uintptr  // 期望的栈顶，用于回溯检查
15
  param        unsafe.Pointer // 传递的参数（如 channel 发送的值、等待的结果）
16
  atomicstatus atomic.Uint32   // G 的状态
17
  stackLock    uint32          // 栈增长时的锁
18
  goid         uint64          // 全局唯一的 Goroutine ID
19
  schedlink    guintptr        // 链表指针，用于将 G 放入全局队列
20
  waitsince    int64           // G 进入等待状态的近似时间
21
  waitreason   waitReason      // 等待原因（如 channel、select、time.Sleep）
22

23
  preempt       bool          // 抢占信号（栈抢占）
24
  preemptStop   bool          // 抢占时是否转换到 _Gpreempted
25
  preemptShrink bool          // 在同步安全点进行抢占
26

27
  lockedm       muintptr      // LockOSThread 锁定的 M
28

29
  // ... 更多字段
30
}

1
type m struct {
2
  g0      *g           // 拥有调度栈的 Goroutine
3
  morebuf gobuf        // gobuf 传给更高级别的调用
4
  divmod  uint32       // 除法/取模的分母
5

6
  // Fields not protected by anything
7
  procid        uint64        // 调试用的处理器 ID
8
  gsignal       *g            // 处理信号的 G
9
  goSigStack    gsignalStack  // 信号处理栈
10
  sigmask       sigset        // 信号掩码
11
  tls           [tlsSlots]uintptr // 线程本地存储
12
  mstartfn      func()        // M 启动时执行的函数
13
  curg          *g            // 当前正在运行的 G
14
  caughtsig     guintptr      // 捕获信号的 G 的指针
15
  p             puintptr      // 绑定的 P
16
  nextp         puintptr      // 将要绑定的 P
17
  oldp          puintptr      // 系统调用前的 P
18
  id            int64         // M 的唯一 ID
19
  mallocing     int32         // 是否正在分配内存
20
  throwing      throwType     // 是否正在 throw
21
  preemptoff    string        // 如果 != "" 则禁止抢占
22
  locks         int32         // 持有的锁计数
23
  dying         int32         // 是否正在退出
24
  profilehz     int32         // 性能分析的频率
25
  spinning      bool          // M 是否处于自旋状态（没有工作，正在找工作）
26
  blocked       bool          // M 是否阻塞（在 note 上）
27
  newSigstack   bool          // C 线程调用了 Go 的 sigaltstack
28
  printlock     int8          // 打印锁
29
  incgo         bool          // M 是否正在执行 cgo 调用
30
  isExtra       bool          // M 是否为一个 "extra" M（由 needm 创建）
31
  freeWait      atomic.Uint32
32
  needextram    bool
33
  traceback     uint8
34
  ncgocall      uint64     // cgo 调用总数
35
  ncgo          int32      // 当前 cgo 调用数量
36

37
  // ... 更多字段
38
}

1
type p struct {
2
  id          int32
3
  status      uint32    // p 的状态: _Pidle, _Prunning, _Psyscall, _Pgcstop, _Pdead
4
  link        puintptr  // 下一个空闲 P
5
  m           muintptr  // 反向链接到关联的 M（如果有）
6
  mcache      *mcache   // 每个 P 的内存缓存
7
  pcache      pageCache // 每个 P 的页缓存
8
  deferpool   []*_defer // 可复用的 defer 结构池
9

10
  racectx     uintptr
11

12
  // G 的可运行队列，无锁访问
13
  runqhead uint32    // 队列头
14
  runqtail uint32    // 队列尾
15
  runq     [256]guintptr // 最多存 256 个 G（环形缓冲区）
16
  runnext  guintptr  // 下一个可运行的 G（高优先级）
17

18
  // 已完成的 G（这些 G 可以复用）
19
  gFree struct {
20
    gList
21
    n int32
22
  }
23

24
  // 调度器追踪
25
  sudogcache []*sudog   // sudog 缓存池
26
  sudogbuf   [128]*sudog
27

28
  // 用于性能分析
29
  palloc persistentAlloc
30

31
  timer0When        atomic.Int64
32
  timerModifiedEarliest atomic.Int64
33

34
  // GC 相关
35
  gcAssistTime         int64 // 协助 GC 的时间
36
  gcFractionalMarkTime int64 // 部分标记时间
37
  gcMarkWorkerMode     gcMarkWorkerMode
38
  gcMarkWorkerStartTime int64
39

40
  // ... 更多字段
41
}

1
type gobuf struct {
2
  sp   uintptr  // 栈指针 (Stack Pointer)
3
  pc   uintptr  // 程序计数器 (Program Counter)
4
  g    guintptr // 持有 gobuf 的 G
5
  ctxt unsafe.Pointer // 闭包的上下文
6
  ret  uintptr  // 系统调用的返回值
7
  lr   uintptr  // 链接寄存器 (ARM)
8
  bp   uintptr  // 基址指针 (x86 frame pointer)
9
}

1
type schedt struct {
2
  goidgen   atomic.Uint64  // 全局 G ID 生成器
3
  lastpoll  atomic.Int64   // 上次轮询网络的时间
4

5
  lock mutex  // 全局调度器锁
6

7
  midle        muintptr    // 空闲 M 链表
8
  nmidle       int32       // 空闲 M 数量
9
  nmidlelocked int32       // 锁定的空闲 M 数量
10
  mnext        int64       // 下一个 M 的 ID
11
  maxmcount    int32       // M 的最大数量限制
12
  nM sys32                 // 死掉的 M 数量
13

14
  pidle        puintptr    // 空闲 P 链表
15
  npidle       atomic.Int32 // 空闲 P 数量
16

17
  // 全局可运行 G 队列
18
  runq     gQueue    // 全局 run queue
19
  runqsize int32     // 全局 run queue 大小
20

21
  // 全局已死 G 的缓存
22
  gFree struct {
23
    lock    mutex
24
    stack   gList  // 包含栈的 G
25
    noStack gList  // 不包含栈的 G
26
    n       int32
27
  }
28

29
  // 等待释放的 M
30
  mfreedefer struct {
31
    lock  mutex
32
    stack gList
33
  }
34

35
  // sysmon 触发的 GC 次数
36
  ngsys atomic.Int32
37

38
  // 调度器终止标志
39
  schedtick atomic.Int64
40
}

1
// Create a new g running fn.
2
// Put it on the queue of g's waiting to run.
3
// The compiler turns a go statement into a call to this.
4
func newproc(fn *funcval) {
5
  gp := getg()            // 获取当前 G
6
  pc := getcallerpc()     // 获取调用者的 PC（即 "go" 语句的地址）
7
  systemstack(func() {    // 切换到 g0 栈执行
8
    newg := newproc1(fn, gp, pc)
9

10
    pp := getg().m.p.ptr()
11
    runqput(pp, newg, true) // 将新 G 放入 P 的本地队列
12

13
    if mainStarted {
14
      wakep()            // 唤醒一个空闲的 P 或创建新的 M
15
    }
16
  })
17
}

1
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
2
  // ... 省略错误处理
3

4
  _g_ := getg()
5
  acquirem()                // 禁止被抢占
6
  pp := _g_.m.p.ptr()
7

8
  // 尝试从 P 的 gFree 列表获取一个已死亡的 G 来复用
9
  newg := gfget(pp)
10
  if newg == nil {
11
    // 创建一个新的 G，分配 2KB 栈
12
    newg = malg(_StackMin) // _StackMin = 2048
13
    casgstatus(newg, _Gidle, _Gdead)
14
    allgadd(newg)
15
  }
16

17
  // 初始化 G 的栈
18
  totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize)
19
  totalSize += -totalSize & (sys.SpAlign - 1)
20
  sp := newg.stack.hi - totalSize
21
  spArg := sp
22

23
  // 设置退出函数（确保 goroutine 结束时清理）
24
  memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
25
  newg.sched.sp = sp
26
  newg.stktopsp = sp
27
  newg.sched.pc = abi.FuncPCABI0(goexit)     // 设置为 goexit 使 G 能退出
28
  newg.sched.g = guintptr(unsafe.Pointer(newg))
29
  gostartcallfn(&newg.sched, fn)               // 将 fn 压入栈帧
30
  newg.gopc = callerpc
31
  newg.startpc = fn.fn
32
  casgstatus(newg, _Gdead, _Grunnable)
33

34
  // 分配 goid
35
  if pp.goidcache == pp.goidcacheend {
36
    pp.goidcache = sched.goidgen.Add(64)
37
    pp.goidcacheend = pp.goidcache + 64
38
  }
39
  newg.goid = pp.goidcache
40
  pp.goidcache++
41

42
  releasem(_g_.m)
43
  return newg
44
}

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

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

10
  if mp.lockedg != 0 {
11
    stoplockedm()
12
    execute(mp.lockedg.ptr(), false) // Never returns.
13
  }
14

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

21
top:
22
  pp := mp.p.ptr()
23
  pp.preempt = false
24

25
  // Safety check: 如果有 GC 等待则不应该调度
26
  if gcBlackenEnabled != 0 {
27
    gcBlackenEnabled = 0
28
  }
29

30
  // 定时器检查：检查第一个定时器是否到期
31
  checkTimers(pp, 0)
32

33
  var gp *g
34

35
  // ======== 步骤 1: 每 61 次调度，从全局队列取一个 G ========
36
  // 这个机制确保全局队列中的 G 不会被饿死
37
  if pp.schedtick%61 == 0 && sched.runqsize > 0 {
38
    lock(&sched.lock)
39
    gp = globrunqget(pp, 1) // 从全局队列拿 1 个 G
40
    unlock(&sched.lock)
41
  }
42

43
  // ======== 步骤 2: 从本地队列获取 ========
44
  if gp == nil {
45
    gp, inheritTime = runqget(pp)
46
  }
47

48
  // ======== 步骤 3: 从别处找可运行的 G ========
49
  if gp == nil {
50
    gp, inheritTime = findRunnable() // blocks until work is available
51
  }
52

53
  // ======== 步骤 4: 执行找到的 G ========
54
  // 这个函数永不返回（它会通过 mcall 切回 schedule）
55
  execute(gp, inheritTime)
56
}

1
// Finds a runnable goroutine to execute.
2
// Tries to steal from other P's, get from global queue, poll network.
3
func findRunnable() (gp *g, inheritTime bool) {
4
  mp := getg().m
5

6
top:
7
  pp := mp.p.ptr()
8

9
  // 检查 GC 是否在等待
10
  if sched.gcwaiting.Load() {
11
    gcstopm()
12
    goto top
13
  }
14

15
  // 检查定时器
16
  now, pollUntil, changed := checkTimers(pp, 0)
17

18
  // 1. 检查本地 runq
19
  if gp, inheritTime := runqget(pp); gp != nil {
20
    return gp, inheritTime
21
  }
22

23
  // 2. 检查全局 runq
24
  if sched.runqsize != 0 {
25
    lock(&sched.lock)
26
    gp := globrunqget(pp, 0) // 获取一批 G（最多 n = sched.runqsize/gomaxprocs + 1）
27
    unlock(&sched.lock)
28
    if gp != nil {
29
      return gp, false
30
    }
31
  }
32

33
  // 3. 非阻塞地轮询网络
34
  if netpollinited() && netpollAnyWaiters() {
35
    if list := netpoll(0); !list.empty() {
36
      gp := list.pop()
37
      injectglist(&list) // 将剩余的 G 放入全局队列
38
      casgstatus(gp, _Gwaiting, _Grunnable)
39
      return gp, false
40
    }
41
  }
42

43
  // 4. 工作窃取：尝试从其他 P 偷一半可运行的 G
44
  //    (4 次尝试，每次从随机 P 偷)
45
  if mp.spinning {
46
    mp.spinning = false
47
  }
48
  procs := gomaxprocs
49
  if procs > 1 {
50
    for i := 0; i < int(procs); i++ {
51
      pp := allp[cheaprand()%procs]
52
      if pp == nil || pp == _p_ {
53
        continue
54
      }
55
      //
56
      // Steal half of pp's run queue.
57
      //
58
      if gp := runqsteal(_p_, pp, stealRunNextG); gp != nil {
59
        return gp, true
60
      }
61
    }
62
  }
63

64
  // ... 后续：再次检查各种来源，包括阻塞等待的 netpoll
65
  // 如果多次尝试都找不到，最终 stopm() 休眠 M
66
  stopm()
67
  goto top
68
}

1
// runqput 将 G 放入 P 的本地队列
2
func runqput(pp *p, gp *g, next bool) {
3
  if randomizeScheduler && next && fastrandn(2) == 0 {
4
    next = false
5
  }
6

7
  if next {
8
    // 如果 runnext 为空，直接放入 runnext（高优先级）
9
    oldnext := pp.runnext
10
    if !pp.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
11
      goto retryNext
12
    }
13
    if oldnext == 0 {
14
      return
15
    }
16
    // 原来的 runnext 放入队列
17
    gp = oldnext.ptr()
18
  }
19

20
retry:
21
  h := atomic.LoadAcq(&pp.runqhead)
22
  t := pp.runqtail
23
  if t-h < uint32(len(pp.runq)) {
24
    // 队列未满，直接放入
25
    pp.runq[t%uint32(len(pp.runq))].set(gp)
26
    atomic.StoreRel(&pp.runqtail, t+1)
27
    return
28
  }
29
  // 本地队列满了，将一半放入全局队列
30
  if runqputslow(pp, gp) {
31
    return
32
  }
33
  goto retry
34
}

1
func runqget(pp *p) (gp *g, inheritTime bool) {
2
  // 优先获取 runnext（高优先级）
3
  for {
4
    next := pp.runnext
5
    if next == 0 {
6
      break
7
    }
8
    if pp.runnext.cas(next, 0) {
9
      return next.ptr(), true
10
    }
11
  }
12

13
  // 从 runq 头部取
14
  for {
15
    h := atomic.LoadAcq(&pp.runqhead)
16
    t := pp.runqtail
17
    if t == h {
18
      return nil, false
19
    }
20
    gp := pp.runq[h%uint32(len(pp.runq))].ptr()
21
    if atomic.CasRel(&pp.runqhead, h, h+1) {
22
      return gp, false
23
    }
24
  }
25
}

1
// Steal half of items from runq of p2 and put onto runq of p.
2
// Returns the stolen goroutine, which may be nil.
3
func runqsteal(pp, p2 *p, stealRunNextG bool) *g {
4
  t := pp.runqtail
5
  n := runqgrab(p2, &pp.runq, t, stealRunNextG)
6
  if n == 0 {
7
    return nil
8
  }
9
  // 返还一个 G 给自己
10
  n--
11
  gp := pp.runq[(t+n)%uint32(len(pp.runq))].ptr()
12
  if n == 0 {
13
    return gp
14
  }
15
  h := atomic.LoadAcq(&pp.runqhead)
16
  if t-h+n >= uint32(len(pp.runq)) {
17
    throw("runqsteal: runq overflow")
18
  }
19
  atomic.StoreRel(&pp.runqtail, t+n)
20
  return gp
21
}
22

23
// runqgrab 从 p2 的队列中抓取一批 G
24
func runqgrab(pp *p, batch *[256]guintptr, batchHead uint32, stealRunNextG bool) uint32 {
25
  for {
26
    h := atomic.LoadAcq(&pp.runqhead)
27
    t := atomic.LoadAcq(&pp.runqtail)
28
    n := t - h                // 队列中 G 的数量
29
    n = n - n/2               // 取一半
30
    if n == 0 {
31
      return 0
32
    }
33
    // 将 G 从 p2 复制到 batch
34
    for i := uint32(0); i < n; i++ {
35
      g := pp.runq[(h+i)%uint32(len(pp.runq))].ptr()
36
      batch[(batchHead+i)%uint32(len(batch))].set(g)
37
    }
38
    if atomic.CasRel(&pp.runqhead, h, h+n) {
39
      return n
40
    }
41
  }
42
}

1
// 每 61 次调度，强制从全局队列取一次
2
if pp.schedtick%61 == 0 && sched.runqsize > 0 {
3
  lock(&sched.lock)
4
  gp = globrunqget(pp, 1) // 取 1 个
5
  unlock(&sched.lock)
6
}

1
// 当自旋的 M 在找工作时，它不释放 P
2
// 这样当真正的 G 到来时能立即执行，避免 M 唤醒的延迟
3

4
func stopm() {
5
  _g_ := getg()
6

7
  if _g_.m.spinning {
8
    _g_.m.spinning = false
9
    nmspinning := sched.nmspinning.Add(-1)
10
    // ...
11
  }
12
  lock(&sched.lock)
13
  mput(_g_.m)    // 将 M 放入空闲列表
14
  unlock(&sched.lock)
15
  mPark()
16
  // ... 被唤醒后继续执行
17
}

1
// doSigPreempt 处理通过信号发送的抢占请求
2
func doSigPreempt(gp *g, ctxt *sigctxt) {
3
  // 检查 G 是否可以被安全地抢占
4
  if wantAsyncPreempt(gp) {
5
    if ok, newpc := isAsyncSafePoint(gp, ctxt.pc(), ctxt.sp(), ctxt.lr()); ok {
6
      // 调整 PC 使其进入 asyncPreempt
7
      ctxt.pushCall(abi.FuncPCABI0(asyncPreempt), newpc)
8
    }
9
  }
10
}

1
// isAsyncSafePoint 检查当前代码位置是否可以作为异步抢占的安全点
2
// 安全点要求：
3
// - 不在编译器的写屏障中
4
// - 不在运行时关键区域
5
// - 不在系统调用中
6
func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) {
7
  // ... 安全检查
8
  return true, pc
9
}

1
// asyncPreempt 由信号处理函数跳转进入
2
// 功能：保存现场，切换到 g0，调用 schedule
3
func asyncPreempt() {
4
  // 由汇编实现，在 runtime/asm_amd64.s
5
  // 核心：保存当前 G 的寄存器 → 设置 preemptStop/preempt → mcall(gopreempt_m)
6
}

1
// reentersyscall 在进入系统调用前调用
2
func reentersyscall(pc, sp uintptr) {
3
  _g_ := getg()
4

5
  // 禁止抢占
6
  _g_.m.locks++
7

8
  // 保存调度上下文
9
  _g_.syscallsp = sp
10
  _g_.syscallpc = pc
11
  casgstatus(_g_, _Grunning, _Gsyscall)
12

13
  // P 的状态转换
14
  pp := _g_.m.p.ptr()
15
  pp.m = 0                           // 解绑 M
16
  pp.oldm = _g_.m                    // 记录旧的 M（用于快速恢复）
17
  atomic.Store(&pp.status, _Psyscall)
18

19
  _g_.m.locks--
20
}

1
// 当进入阻塞式系统调用时调用，将 P 转交给其他 M
2
func entersyscallblock() {
3
  _g_ := getg()
4

5
  _g_.m.locks++
6
  _g_.syscallsp = _g_.sched.sp
7
  _g_.syscallpc = _g_.sched.pc
8
  casgstatus(_g_, _Grunning, _Gsyscall)
9

10
  systemstack(func() {
11
    entersyscallblock_handoff(_g_.syscallsp, _g_.syscallpc)
12
  })
13

14
  _g_.m.locks--
15
}
16

17
func entersyscallblock_handoff(sp, pc uintptr) {
18
  _g_ := getg()
19
  pp := _g_.m.p.ptr()
20
  pp.m = 0
21
  _g_.m.oldp.set(pp)
22
  _g_.m.p = 0
23
  atomic.Store(&pp.status, _Psyscall)
24

25
  // 将 P 交给其他能用的 M
26
  handoffp(pp)
27
}

1
func handoffp(pp *p) {
2
  // 1. 如果本地队列或全局队列中有可运行的 G，直接启动一个 M
3
  if !runqempty(pp) || sched.runqsize != 0 {
4
    startm(pp, false, false)
5
    return
6
  }
7

8
  // 2. 如果有自旋的 M，它会把 P 捡起来
9
  if sched.nmspinning.Load()+sched.npidle.Load() == 0 &&
10
    sched.nmspinning.CompareAndSwap(0, 1) {
11
    startm(pp, true, false)
12
    return
13
  }
14

15
  // 3. 否则把 P 放入全局空闲列表
16
  lock(&sched.lock)
17
  pidleput(pp, 0)
18
  unlock(&sched.lock)
19
}

1
func exitsyscall() {
2
  _g_ := getg()
3

4
  // 尝试快速路径：重新绑定原来的 P
5
  oldp := _g_.m.oldp.ptr()
6
  _g_.m.oldp = 0
7
  if exitsyscallfast(oldp) {
8
    // 成功！恢复执行
9
    casgstatus(_g_, _Gsyscall, _Grunning)
10
    return
11
  }
12

13
  // 慢速路径：需要重新获取 P
14
  mcall(exitsyscall0) // 切换到 g0 栈执行
15
}
16

17
func exitsyscallfast(oldp *p) bool {
18
  // 快速路径：如果原来的 P 仍然空闲且状态是 _Psyscall
19
  if oldp != nil && oldp.status == _Psyscall &&
20
    oldp.runqhead == oldp.runqtail &&
21
    atomic.Cas(&oldp.status, _Psyscall, _Pidle) {
22
    // 重新绑定
23
    wirep(oldp)
24
    exitsyscallfast_reacquired(oldp)
25
    return true
26
  }
27
  return false
28
}
29

30
func exitsyscall0(gp *g) {
31
  casgstatus(gp, _Gsyscall, _Grunnable)
32

33
  // 获取一个空闲 P
34
  pp, _ := pidleget(0)
35
  if pp == nil {
36
    // 没有空闲 P，将 G 放入全局队列
37
    globrunqput(gp)
38
    stopm()
39
  }
40

41
  // 有 P，绑定并继续调度
42
  acquirep(pp)
43
  execute(gp, false)
44
}

1
// netpoll 检查网络连接的就绪情况
2
// mode: 0 = 非阻塞，1 = 阻塞直到有就绪的连接
3
func netpoll(mode int32) gList {
4
  pollUntil := int64(-1)
5
  if mode != 0 {
6
    pollUntil = 0
7
  }
8

9
  // 调用平台特定的轮询
10
  events, delta := netpollcheck(0, pollUntil)
11
  if len(events) == 0 {
12
    return gList{}
13
  }
14

15
  // 将就绪的 G 从等待态转为可运行态
16
  var toRun gList
17
  for i := range events {
18
    ev := &events[i]
19
    gp := ev.g()
20
    netpollready(&toRun, gp, ev.mode)
21
  }
22
  return toRun
23
}

1
// sysmon 是一个独立的 M（不需要 P），用于系统监控
2
func sysmon() {
3
  // 运行在一个死循环中
4
  for {
5
    // 如果已有 50µs 空闲，则无需 P
6
    usleep(delay)
7

8
    // === 1. 抢占长时间运行的 G ===
9
    if preemptlongrunning(delay) {
10
      // 检查是否有 P 运行同一 G 超过 10ms
11
      preemptone(pp)  // 发送信号抢占
12
    }
13

14
    // === 2. 网络轮询 ===
15
    lastpoll := sched.lastpoll.Load()
16
    if netpollinited() && lastpoll != 0 && lastpoll+10*1000*1000 < now {
17
      list := netpoll(0) // 非阻塞轮询
18
      // 将就绪的 G 放入全局队列
19
      injectglist(&list)
20
    }
21

22
    // === 3. 抢夺阻塞在系统调用上的 P ===
23
    if retake(now) != 0 {
24
      // ...
25
    }
26

27
    // === 4. 触发 GC ===
28
    if gcShouldStart() {
29
      // ...
30
    }
31
  }
32
}

1
func retake(now int64) uint32 {
2
  n := 0
3
  // 防止 allp 被改变
4
  lock(&allpLock)
5
  for i := 0; i < len(allp); i++ {
6
    pp := allp[i]
7
    if pp == nil {
8
      continue
9
    }
10
    pd := &pp.sysmontick
11
    s := pp.status
12

13
    if s == _Prunning || s == _Psyscall {
14
      // Preempt G if it's running for too long.
15
      t := int64(pp.schedtick) // 调度计数
16
      if int64(pd.schedtick) != t {
17
        pd.schedtick = uint32(t)
18
        pd.schedwhen = now
19
      } else if pd.schedwhen+forcePreemptNS <= now {
20
        preemptone(pp)
21
      }
22
    }
23

24
    if s == _Psyscall {
25
      // Retake P from syscall if it's been there for too long.
26
      t := int64(pp.syscalltick)
27
      if pd.syscalltick != t {
28
        pd.syscalltick = uint32(t)
29
        pd.syscallwhen = now
30
        continue
31
      }
32
      // 如果 runq 中有工作或全局队列不为空，且已经过了一段时间
33
      if runqempty(pp) &&
34
        atomic.Load(&sched.npidle) > 0 &&
35
        pd.syscallwhen+10*1000*1000 <= now {
36
        handoffp(pp)
37
      }
38
    }
39
  }
40
  unlock(&allpLock)
41
  return uint32(n)
42
}