追溯Go中sysmon的启动过程

在Go中有一个特殊的线程，它不与其他任何P进行绑定。在一个死循环之中不停的执行一系列的监控操作，通过这些监控操作来更好的服务于整个Go进程，它就是——sysmon监控线程。

你可能会好奇它的作用，这里简单总结一下：

  • 释放闲置超过5分钟的span物理内存
  • 超过2分钟没有垃圾回收，强制启动垃圾回收
  • 将长时间没有处理的netpoll结果添加到任务队列
  • 向长时间执行的G任务发起抢占调度
  • 收回因syscall而长时间阻塞的P

因此可以看出，sysmon线程就像监工一样，监控着整个进程的状态。你会不会跟我一样好奇这个线程是怎么启动起来的，一起来追溯吧。

1. 准备工作

  • Go源码：v1.16.5
  • IDE：goland
  • 操作系统：Centos
  • 知识储备：了解Go启动过程，见笔者文章《Go程序启动过程的一次追溯》

Go的启动过程大概分为三个阶段：

  • Go程序的引导过程
  • runtime的启动以及初始化过程(runtime.main)
  • 执行用户代码(main.main)

2. sysmon启动过程追溯

由Go的启动过程大概可以猜出来，sysmon的启动过程在runtime的启动以及初始化过程之中。所以，我们从runtime.main开始一步步的追溯代码，来寻找sysmon的启动步骤。

runtime/proc.go

 
 
 
      
  
  
  1. func main() { 
    2.   
  
  
  2.     ... 
    3.   
  
  
  3.       if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon 
    4.   
  
  
  4.       // For runtime_syscall_doAllThreadsSyscall, we 
    5.   
  
  
  5.       // register sysmon is not ready for the world to be 
    6.   
  
  
  6.       // stopped. 
    7.   
  
  
  7.        
    8.   
  
  
  8.       // !!! 找到了 启动sysmon的代码 
    9.   
  
  
  9.       // 在系统栈内生成一个新的M来启动sysmon 
    10.   
  
  
  10.       atomic.Store(&sched.sysmonStarting, 1) 
    11.   
  
  
  11.         systemstack(func() { 
    12.   
  
  
  12.           newm(sysmon, nil, -1) 
    13.   
  
  
  13.       }) 
    14.   
  
  
  14.     } 
    15.   
  
  
  15.   ... 
    16.   
  
  
  16. } 
    17.   
  
  
  17.  
    18.   
  
  
  18. // 创建一个新的系统线程 
    19.   
  
  
  19. // Create a new m. It will start off with a call to fn, or else the scheduler. 
    20.   
  
  
  20. // fn needs to be static and not a heap allocated closure. 
    21.   
  
  
  21. // May run with m.p==nil, so write barriers are not allowed. 
    22.   
  
  
  22. // 
    23.   
  
  
  23. // id is optional pre-allocated m ID. Omit by passing -1. 
    24.   
  
  
  24. //go:nowritebarrierrec 
    25.   
  
  
  25. func newm(fn func(), _p_ *p, id int64) { 
    26.   
  
  
  26.     // 获取GPM中M结构体，并进行部分字段的初始化 
    27.   
  
  
  27.     // allocm方法非常重要！！！ 
    28.   
  
  
  28.     // 该方法获取并初始化M的结构体，还在M里面设置了系统线程将要执行的方法fn，这里是sysmon 
    29.   
  
  
  29.     mp := allocm(_p_, fn, id) 
    30.   
  
  
  30.     ... 
    31.   
  
  
  31.    
    32.   
  
  
  32.      // M在Go中属于用户态代码中的一个结构体，跟系统线程是一对一的关系 
    33.   
  
  
  33.      // 每个系统线程怎么执行代码，从哪里开始执行，则是由M的结构体中参数来指明 
    34.   
  
  
  34.     // 创建GPM中结构体M结构体之后，开始创建对应的底层系统线程 
    35.   
  
  
  35.     newm1(mp) 
    36.   
  
  
  36. } 
    37.   
  
  
  37.  
    38.   
  
  
  38. // 给M分配一个系统线程 
    39.   
  
  
  39. // Allocate a new m unassociated with any thread. 
    40.   
  
  
  40. // Can use p for allocation context if needed. 
    41.   
  
  
  41. // fn is recorded as the new m's m.mstartfn. 
    42.   
  
  
  42. // id is optional pre-allocated m ID. Omit by passing -1. 
    43.   
  
  
  43. // 
    44.   
  
  
  44. // This function is allowed to have write barriers even if the caller 
    45.   
  
  
  45. // isn't because it borrows _p_. 
    46.   
  
  
  46. // 
    47.   
  
  
  47. //go:yeswritebarrierrec 
    48.   
  
  
  48. func allocm(_p_ *p, fn func(), id int64) *m { 
    49.   
  
  
  49.     ... 
    50.   
  
  
  50.     // 创建新的M，并且进行一些初始化操作 
    51.   
  
  
  51.     mp := new(m) 
    52.   
  
  
  52.     // M 的执行方法, 在runtime.mstart()方法中最终调用fn 
    53.   
  
  
  53.     mp.mstartfn = fn 
    54.   
  
  
  54.     ... 
    55.   
  
  
  55. } 
    56.   
  
  
  56.  
    57.   
  
  
  57. // 楷书创建系统线程的逻辑 
    58.   
  
  
  58. func newm1(mp *m) { 
    59.   
  
  
  59.       ... 
    60.   
  
  
  60.       // ！！！创建系统线程！！！ 
    61.   
  
  
  61.       newosproc(mp) 
    62.   
  
  
  62.       ... 
    63.   
  
  
  63. } 
    64.

 runtime/os_linux.go

 
 
 
      
  
  
  1. // 通过clone创建系统线程 
    2.   
  
  
  2. // May run with m.p==nil, so write barriers are not allowed. 
    3.   
  
  
  3. //go:nowritebarrier 
    4.   
  
  
  4. func newosproc(mp *m) { 
    5.   
  
  
  5.     ... 
    6.   
  
  
  6.     // Disable signals during clone, so that the new thread starts 
    7.   
  
  
  7.     // with signals disabled. It will enable them in minit. 
    8.   
  
  
  8.    // 
    9.   
  
  
  9.    // 注意： 
    10.   
  
  
  10.    // 第5个参数 mstart 是在 runtime.mstart 
    11.   
  
  
  11.     ret := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(funcPC(mstart))) 
    12.   
  
  
  12.     ... 
    13.   
  
  
  13. } 
    14.   
  
  
  14.  
    15.   
  
  
  15. //go:noescape 
    16.   
  
  
  16. //clone没有具体方法体，具体实现使用汇编编写 
    17.   
  
  
  17. func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32 
    18.

 clone()函数在linux系统中，用来创建轻量级进程

runtime/sys_linux_arm64.s

 
 
 
      
  
  
  1. // 注意 这里的void (*fn)(void) 就是 runtime.mstart 方法的地址入口 
    2.   
  
  
  2. // 
    3.   
  
  
  3. // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void)); 
    4.   
  
  
  4. TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0 
    5.   
  
  
  5.     ... 
    6.   
  
  
  6.     // Copy mp, gp, fn off parent stack for use by child. 
    7.   
  
  
  7.     MOVD    mp+16(FP), R10 
    8.   
  
  
  8.     MOVD    gp+24(FP), R11 
    9.   
  
  
  9.     MOVD    fn+32(FP), R12 // R12寄存器存储fn的地址 
    10.   
  
  
  10.     ... 
    11.   
  
  
  11.      
    12.   
  
  
  12.     // 判断是父进程，则直接返回 
    13.   
  
  
  13.     // 子进程则跳到 child 
    14.   
  
  
  14.     // In parent, return. 
    15.   
  
  
  15.     CMP ZR, R0 
    16.   
  
  
  16.     BEQ child 
    17.   
  
  
  17.     MOVW    R0, ret+40(FP) 
    18.   
  
  
  18.     RET 
    19.   
  
  
  19.      
    20.   
  
  
  20. child: 
    21.   
  
  
  21.     // In child, on new stack. 
    22.   
  
  
  22.     MOVD    -32(RSP), R10 
    23.   
  
  
  23.     MOVD    $1234, R0 
    24.   
  
  
  24.     CMP R0, R10 
    25.   
  
  
  25.     BEQ good 
    26.   
  
  
  26.     ... 
    27.   
  
  
  27.  
    28.   
  
  
  28. good: 
    29.   
  
  
  29.     ... 
    30.   
  
  
  30.     CMP $0, R10 
    31.   
  
  
  31.     BEQ nog 
    32.   
  
  
  32.     CMP $0, R11 
    33.   
  
  
  33.     BEQ nog 
    34.   
  
  
  34.     ... 
    35.   
  
  
  35. nog: 
    36.   
  
  
  36.     // Call fn,  调用 fn，即 runtime.mstart 
    37.   
  
  
  37.     MOVD    R12, R0 // R12中存放的是fn的地址 
    38.   
  
  
  38.     BL  (R0)  // BL是一个跳转指令，跳转到fn 
    39.   
  
  
  39. ... 
    40.

 runtime.proc.go

 
 
 
      
  
  
  1. // mstart是一个M的执行入口 
    2.   
  
  
  2. // mstart is the entry-point for new Ms. 
    3.   
  
  
  3. // 
    4.   
  
  
  4. // This must not split the stack because we may not even have stack 
    5.   
  
  
  5. // bounds set up yet. 
    6.   
  
  
  6. // 
    7.   
  
  
  7. // May run during STW (because it doesn't have a P yet), so write 
    8.   
  
  
  8. // barriers are not allowed. 
    9.   
  
  
  9. // 
    10.   
  
  
  10. //go:nosplit 
    11.   
  
  
  11. //go:nowritebarrierrec 
    12.   
  
  
  12. func mstart() { 
    13.   
  
  
  13.     ... 
    14.   
  
  
  14.     mstart1() 
    15.   
  
  
  15.     ... 
    16.   
  
  
  16. } 
    17.   
  
  
  17.  
    18.   
  
  
  18. // 开始执行M的具体方法 
    19.   
  
  
  19. func mstart1() { 
    20.   
  
  
  20.     _g_ := getg() 
    21.   
  
  
  21.    
    22.   
  
  
  22.     ... 
    23.   
  
  
  23.     // M中mstartfn指向 runtime.sysmon， 即 fn = runtime.sysmon 
    24.   
  
  
  24.     if fn := _g_.m.mstartfn; fn != nil { 
    25.   
  
  
  25.     // 即：执行 runtime.sysmon 
    26.   
  
  
  26.     // sysmon方法是一个死循环，所以说执行sysmon的线程会一直在这里 
    27.   
  
  
  27.     fn() 
    28.   
  
  
  28.     } 
    29.   
  
  
  29.     ... 
    30.   
  
  
  30. } 
    31.

最终执行的sysmon方法

 
 
 
      
  
  
  1. // Always runs without a P, so write barriers are not allowed. 
    2.   
  
  
  2. // 
    3.   
  
  
  3. //go:nowritebarrierrec 
    4.   
  
  
  4. func sysmon() { 
    5.   
  
  
  5.     ... 
    6.   
  
  
  6.     for { 
    7.   
  
  
  7.        ... 
    8.   
  
  
  8.       // 获取超过10ms的netpoll结果 
    9.   
  
  
  9.       // 
    10.   
  
  
  10.       // poll network if not polled for more than 10ms 
    11.   
  
  
  11.       lastpoll := int64(atomic.Load64(&sched.lastpoll)) 
    12.   
  
  
  12.       if netpollinited() && lastpoll != 0 && lastpoll+10*1000*1000 < now { 
    13.   
  
  
  13.         atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now)) 
    14.   
  
  
  14.         list := netpoll(0) // non-blocking - returns list of goroutines 
    15.   
  
  
  15.         if !list.empty() { 
    16.   
  
  
  16.           // Need to decrement number of idle locked M's 
    17.   
  
  
  17.           // (pretending that one more is running) before injectglist. 
    18.   
  
  
  18.           // Otherwise it can lead to the following situation: 
    19.   
  
  
  19.           // injectglist grabs all P's but before it starts M's to run the P's, 
    20.   
  
  
  20.           // another M returns from syscall, finishes running its G, 
    21.   
  
  
  21.           // observes that there is no work to do and no other running M's 
    22.   
  
  
  22.           // and reports deadlock. 
    23.   
  
  
  23.           incidlelocked(-1) 
    24.   
  
  
  24.           injectglist(&list) 
    25.   
  
  
  25.           incidlelocked(1) 
    26.   
  
  
  26.         } 
    27.   
  
  
  27.       } 
    28.   
  
  
  28.  
    29.   
  
  
  29.             ... 
    30.   
  
  
  30.  
    31.   
  
  
  31.       // 抢夺syscall长时间阻塞的P，向长时间阻塞的P发起抢占调度 
    32.   
  
  
  32.       // 
    33.   
  
  
  33.       // retake P's blocked in syscalls 
    34.   
  
  
  34.       // and preempt long running G's 
    35.   
  
  
  35.       if retake(now) != 0 { 
    36.   
  
  
  36.         idle = 0 
    37.   
  
  
  37.       } else { 
    38.   
  
  
  38.         idle++ 
    39.   
  
  
  39.       } 
    40.   
  
  
  40.      
    41.   
  
  
  41.        // 检查是否需要强制执行垃圾回收 
    42.   
  
  
  42.             // check if we need to force a GC 
    43.   
  
  
  43.       if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && atomic.Load(&forcegc.idle) != 0 { 
    44.   
  
  
  44.         lock(&forcegc.lock) 
    45.   
  
  
  45.         forcegc.idle = 0 
    46.   
  
  
  46.         var list gList 
    47.   
  
  
  47.         list.push(forcegc.g) 
    48.   
  
  
  48.         injectglist(&list) 
    49.   
  
  
  49.         unlock(&forcegc.lock) 
    50.   
  
  
  50.       } 
    51.   
  
  
  51.             ... 
    52.   
  
  
  52.     } 
    53.   
  
  
  53.    ... 
    54.   
  
  
  54. } 
    55.

总结

由以上可知，sysmon线程的创建过程经过几个阶段：

  1. 创建M结构体，对该结构初始化并绑定系统线程将要执行的方法sysmon
  2. 为M创建对应的底层系统线程(不同的操作系统生成方式不同)
  3. 引导系统线程从mstart方法开始执行sysmon逻辑(sysmon方法是死循环)

sysmon线程启动之后就进入监控整个Go进程的逻辑中，至于sysmon都做了些什么，有机会再一起探讨。

本文题目：追溯Go中sysmon的启动过程
链接地址：http://www.csdahua.cn/qtweb/news32/371082.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

解决方案知识

行业网站建设

广安园林景观设计　　 　成都网站制作　　 　wap网站建设　　 　广告吸塑字　　 　成都机柜租用　　 　资阳服务器托管　　 　成都网站设计　　 　微信小程序　　 　网站空间　　 　水泥搅拌车　　 　渠县网站建设　　 　德阳定制网站建设　　 　成都电商解决方案　　 　成都光华机房　　 　网站设计制作　　 　宣传册设计　　 　景区导示设计制作　　 　阿坝网站建设　　 　绵竹网站建设　　 　开元建校