当go程序启动时会启动哪些协程 --runtime.main剖析

一句话：go启动时会启动调度器协程，通过init函数启动forcegchelper ，即GC协程，从main函数中启动了sysmon线程（以一个不受P调度的M的形式存在），启动了bgscavenge和bgsweep 协程用于清理内存。

这是runtime.main的代码剖析，但是也带着我的一些疑问。（go版本：1.24，截取时间24.9.6，runtime.main函数中最新的部分为24.8.9更新）

先提一嘴题外话，在runtime.main前，go会启动GMP的调度器，这包括一个调度器协程，但是具体的代码为汇编代码且在各个处理器架构下各不相同，故本文中不做过多讨论。

第一部分：

// The main goroutine.
func main() {
    mp := getg().m

    // Racectx of m0->g0 is used only as the parent of the main goroutine.
    // It must not be used for anything else.
    mp.g0.racectx = 0

    // Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
    // Using decimal instead of binary GB and MB because
    // they look nicer in the stack overflow failure message.
    if goarch.PtrSize == 8 {
       maxstacksize = 1000000000
    } else {
       maxstacksize = 250000000
    }

    // An upper limit for max stack size. Used to avoid random crashes
    // after calling SetMaxStack and trying to allocate a stack that is too big,
    // since stackalloc works with 32-bit sizes.
    maxstackceiling = 2 * maxstacksize
	// Allow newproc to start new Ms.
	mainStarted = true

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

mp := getg().m

mp.g0.racectx = 0

这行代码获取了当前正在运行的goroutine，并通过getg()函数访问其所属的M结构体（表示操作系统线程）。后将m0的g0 goroutine的racectx字段设置为0，确保这个字段不被用于其他目的。这样做是为了防止竞态条件检测中的上下文信息干扰主goroutine。

接下来的几行是设置32/64位操作系统中栈的大小上限，与本文无关，不过多探讨

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

这里启动了一个监控线程M，且不与其他P绑定，同时不允许GC的写屏障，这是一个很有趣的线程，让我们看看它做了什么

首先，它会进行一系列初始化：

1. 锁定 sched.lock，增加 sched.nmsys 计数器，并调用 checkdead 检查死锁。

2. 解锁 sched.lock。

3. 初始化 lasttrace 为 0。

4. 初始化 idle 为 0，表示连续多少个周期没有唤醒任何人。

5. 初始化 delay 为 0，表示睡眠时间。

然后会启动一个循环，会以一定策略休眠，并定时启动，在启动后，它会做下面几件事：

1. 检查调度器状态：

   如果 schedtrace 未启用且所有 P 都处于空闲状态或等待 GC，则进入深度睡眠。

   如果有任何 P 变为活动状态，则唤醒 sysmon 线程。

2. 网络轮询：

   如果网络轮询超过 10 毫秒未执行，则进行网络轮询，并将可运行的 goroutine 加入调度队列。

3. 处理特定平台的工作：

   对于 NetBSD 平台，处理特定的内核 bug。

4. 垃圾收集和抢占：

   唤醒垃圾收集器（scavenger）如果有请求。

   重新获取被系统调用阻塞的 P，并抢占长时间运行的 G。

5. 强制垃圾收集：

   检查是否需要强制进行垃圾收集，并将 forcegc.g 加入调度队列。

6. 调度跟踪：

   如果启用了调度跟踪，则记录调度信息。

也就是说，这是一个计时器，大部分时间在休眠，少部分时间工作并唤醒一些任务，因此给它一个独立于P的M并不会产生多少次内核态的上下文切换，性能损失在可以接受的范围内。

第二部分

// Lock the main goroutine onto this, the main OS thread,
// during initialization. Most programs won't care, but a few
// do require certain calls to be made by the main thread.
// Those can arrange for main.main to run in the main thread
// by calling runtime.LockOSThread during initialization
// to preserve the lock.
lockOSThread()

if mp != &m0 {
    throw("runtime.main not on m0")
}

// Record when the world started.
// Must be before doInit for tracing init.
runtimeInitTime = nanotime()
if runtimeInitTime == 0 {
    throw("nanotime returning zero")
}

if debug.inittrace != 0 {
    inittrace.id = getg().goid
    inittrace.active = true
}

doInit(runtime_inittasks) // Must be before defer.

// Defer unlock so that runtime.Goexit during init does the unlock too.
needUnlock := true
defer func() {
    if needUnlock {
       unlockOSThread()
    }
}()
	gcenable()

	main_init_done = make(chan bool)
	if iscgo {
		if _cgo_pthread_key_created == nil {
			throw("_cgo_pthread_key_created missing")
		}

		if _cgo_thread_start == nil {
			throw("_cgo_thread_start missing")
		}
		if GOOS != "windows" {
			if _cgo_setenv == nil {
				throw("_cgo_setenv missing")
			}
			if _cgo_unsetenv == nil {
				throw("_cgo_unsetenv missing")
			}
		}
		if _cgo_notify_runtime_init_done == nil {
			throw("_cgo_notify_runtime_init_done missing")
		}

		// Set the x_crosscall2_ptr C function pointer variable point to crosscall2.
		if set_crosscall2 == nil {
			throw("set_crosscall2 missing")
		}
		set_crosscall2()

		// Start the template thread in case we enter Go from
		// a C-created thread and need to create a new thread.
		startTemplateThread()
		cgocall(_cgo_notify_runtime_init_done, nil)
	}

在这一部分，go锁定了这个线程来防止受到打扰，然后进行了一系列doInit
然而有一个有趣的点：为什么解锁的defer语句要放在doInit之后，GPT给出的理由是：需要确保在doInit期间线程一直是锁定状态，防止任何情况锁被解除（而当doInit过程中panic了，解锁并不是第一要务因为程序已经结束了）

接下来go执行了gcenable()这个函数，详细代码如下

func gcenable() {
    // Kick off sweeping and scavenging.
    c := make(chan int, 2)
    go bgsweep(c)
    go bgscavenge(c)
    <-c
    <-c
    memstats.enablegc = true // now that runtime is initialized, GC is okay
}

在这里我们看见它启动了两个协程，分别是清扫协程bgsweep和回收协程bgscavenge

bgsweep 会在执行完成后调用goparkunlock() 进入休眠状态等待唤醒，它的作用是清理未使用的内存块

bgscavenge 会定时进行定时释放内存页

这里有个很有趣的点，这里新建了一个channel，传递它到两个协程中让协程内部塞东西进去，然后在外部通过取出channel内容的方式实现了一个waitgroup（所以为什么不直接使用waitgroup呢）此外协程内部塞了两个数字1进去，而非我们常用的空结构体（空结构体占用的空间比较小）

接下来一长串代码是确保在Cgo环境下的Go运行时能够顺利初始化，确保所有必要的C函数指针都已正确设置，并准备好处理从C到Go的调用。在本文中不详细展开

第三部分

// Run the initializing tasks. Depending on build mode this
// list can arrive a few different ways, but it will always
// contain the init tasks computed by the linker for all the
// packages in the program (excluding those added at runtime
// by package plugin). Run through the modules in dependency
// order (the order they are initialized by the dynamic
// loader, i.e. they are added to the moduledata linked list).
for m := &firstmoduledata; m != nil; m = m.next {
    doInit(m.inittasks)
}

// Disable init tracing after main init done to avoid overhead
// of collecting statistics in malloc and newproc
inittrace.active = false

close(main_init_done)

needUnlock = false
unlockOSThread()

if isarchive || islibrary {
    // A program compiled with -buildmode=c-archive or c-shared
    // has a main, but it is not executed.
    if GOARCH == "wasm" {
       // On Wasm, pause makes it return to the host.
       // Unlike cgo callbacks where Ms are created on demand,
       // on Wasm we have only one M. So we keep this M (and this
       // G) for callbacks.
       // Using the caller's SP unwinds this frame and backs to
       // goexit. The -16 is: 8 for goexit's (fake) return PC,
       // and pause's epilogue pops 8.
       pause(getcallersp() - 16) // should not return
       panic("unreachable")
    }
    return
}
fn := main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime
fn()
	if raceenabled {
		runExitHooks(0) // run hooks now, since racefini does not return
		racefini()
	}

	// Make racy client program work: if panicking on
	// another goroutine at the same time as main returns,
	// let the other goroutine finish printing the panic trace.
	// Once it does, it will exit. See issues 3934 and 20018.
	if runningPanicDefers.Load() != 0 {
		// Running deferred functions should not take long.
		for c := 0; c < 1000; c++ {
			if runningPanicDefers.Load() == 0 {
				break
			}
			Gosched()
		}
	}
	if panicking.Load() != 0 {
		gopark(nil, nil, waitReasonPanicWait, traceBlockForever, 1)
	}
	runExitHooks(0)

	exit(0)
	for {
		var x *int32
		*x = 0
	}
}

在这一部分中进行了一些初始化的操作，停止了性能工具对go初始化的追踪，随后是对特殊情况的判断，然后就开始执行用户代码的main函数，在执行完用户代码后是一些收尾的工作，在这一部分看起来并没有出现我们感兴趣的协程

额外的部分

强制GC协程

在proc.go中我们可以找到一个init函数，里面启动了一个forcegchelper() 通过字面意思理解其为GC任务的协程，在这个协程里面还启动了一些额外的协程，用于完成GC的一些子任务，我们将其视为同一个协程。

关于timer

从1.14之后每个P中都有个最小四叉堆来存储timer的时间，并由调度器协程或sysmon 线程唤醒，因此似乎并没有一个独立的协程来管理和唤醒timer（但是GPT一直说有一个独立的协程，我尝试寻找它所述的协程无果，因此视为无此协程）
但是我又注意到在timer的addHeap函数中会检测网络轮询器netpoll是否启动，如果没有启动的话addHeap函数会调用netpoll初始化函数，说明定时器依赖于网络轮询器

关于netpoll

netpoll是网络轮询器，其初始化位于internal/poll的init函数中，而internal/poll是大部分网络包的一个依赖（net包import了internal/poll包）
因此当用户函数导入网络相关的包时，会自动执行netpoll的初始化，当然，netpoll的初始化也可能发生在timer的addHeap函数中。

关于信号处理器

• 在 Unix-like 系统上，Go runtime 会启动一个协程用于处理操作系统信号，例如 SIGINT、SIGTERM 等。这些协程用于响应外部信号并进行相应处理，例如优雅地关闭程序。

然而，在手头这个版本的go中，我并没有在init和main函数中找到sigenable函数的调用痕迹，就此作罢

后记

这个题目来自于：当go程序启动时，除了执行main的协程外go还启动了哪些协程
然而对于这个问题，多次询问GPT，给出的答案往往不尽相同，这使得我想要深挖一下go启动时到底会干什么。

个人学习笔记，如有错误欢迎指正