Go源码解析之proc.go

Go语言proc.go核心机制与调度深度解析

最新推荐文章于 2025-09-19 11:06:22 发布

原创

最新推荐文章于 2025-09-19 11:06:22 发布 · 365 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#后端

File: proc.go

proc.go是Go语言runtime（运行时）的核心文件之一，它主要负责实现Go程序在操作系统上的进程管理和调度。

具体来说，proc.go文件包含了以下几个重要的组件：

goroutine调度器(Scheduler)：负责在不同的执行流(goroutine)之间进行切换，并保证高效的调度。
操作系统进程(Process)管理器：在操作系统上管理Go程序的进程，包括启动、关闭等相关操作。
垃圾回收器(Garbage collector)：在Go语言中内存管理是自动完成的，proc.go文件中的垃圾回收器实现了自动的垃圾回收机制。
协作式抢占式调度机制：Go语言的调度机制是协作式的而非操作系统级别的抢占式调度，proc.go文件实现了这种机制。

另外，proc.go文件还实现了一些其他的功能，比如处理操作系统信号、管理内存池等。

总之，proc.go文件是Go语言runtime（运行时）的核心文件，它实现了Go语言程序的底层管理和调度机制，保证了Go程序的高效运行和内存安全。

Var:

modinfo

在Go语言中，modinfo变量是一个字符串，用于存储程序的模块信息。

模块信息是用于构建可执行文件和共享库的元数据，它包含模块的名称、版本、作者、许可证和依赖项等信息。这些信息可以供其他程序使用，例如包管理器和构建系统等。

modinfo变量在proc.go文件中被定义，并且在程序启动时被初始化。在程序运行期间，modinfo变量的值可以通过读取特殊的符号"go.buildinfo"来访问。

对于Go语言的标准库，modinfo变量包含了Go语言的版本信息、构建时间、Git提交ID以及构建平台等元数据。这些信息可以用于排查问题、调试和版本控制等操作。

总之，modinfo变量是一个很重要的变量，它保存了Go程序的模块信息，提供了构建程序和共享库所需的元数据，同时还包含了其他有用的信息，是一个便捷的工具。

m0

m0是Go语言运行时中的一个特殊的M（machine），该变量在程序启动时被创建，并且在整个程序的生命周期中仅有一个实例存在。它主要用于处理一些与线程调度和系统调用相关的任务，例如协程的创建和销毁、信号处理、垃圾回收等。可以说，m0是整个Go语言程序的主线程，在所有goroutine开始执行之前，m0会先执行一些必要的初始化操作，例如分配内存等。

具体来说，m0主要拥有以下的作用：

线程调度：m0会负责在程序启动时初始化调度器，并在运行时进行调度操作，例如将等待的goroutine根据一定的策略唤醒。m0还负责调度goroutine的系统级线程，以及协程的创建和销毁。
垃圾回收：m0负责协助垃圾回收器进行工作，包括唤醒goroutine、暂停协程、收集垃圾等。
信号处理：m0处理所有收到的信号，并转交给相应的处理程序进行处理。例如，如果程序收到了SIGINT信号，m0会将信号传递给handleSignal函数进行处理。
内存分配：m0还负责进行内存分配。在程序启动时，m0会负责分配一些必要的内存，例如栈内存、堆内存等。在程序运行时，m0会根据需要分配更多的内存，例如缓存内存等。

总之，m0在Go语言的运行时系统中扮演着至关重要的角色，它是整个程序的核心，负责底层的系统操作和资源管理，在很大程度上决定了程序的性能和可靠性。

g0

g0是指程序启动时创建的第一个goroutine，也被称为系统goroutine。在Go语言中，每个程序至少有一个goroutine，该goroutine在程序启动时自动创建。g0的作用包括：

执行底层系统函数：g0会执行一些与底层系统相关的工作，例如初始化内存管理器、建立网络连接、读写文件、处理信号等。
调度其他goroutine：g0还负责调度其他goroutine，即为其他goroutine分配P和执行时间。它是整个调度器的控制中心，每当一个P闲置时，g0会检查全局的goroutine队列和P的本地队列，决定哪个goroutine应该被执行。
处理异常：g0也负责处理发生在底层系统级别和Go程序中的异常。例如，当程序遇到致命错误时，g0会关闭所有的goroutine并打印错误信息，然后结束程序运行。

总之，g0对于整个Go程序的正常运行非常关键，它承担着系统级别的调度和异常处理等重要任务。

mcache0

变量mcache0是一个类型为mcache的结构体变量，它被定义在proc.go文件中。它具有如下作用：

作为当前goroutine的本地缓存

mcache0作为当前goroutine的本地缓存，储存了该goroutine最常用的一些heap对象，比如小的block、span等。采用本地缓存的方式，避免了多个goroutine之间的锁竞争，从而提高了程序的执行效率。

用于heap对象的分配

当一个goroutine需要分配heap对象时，它会首先尝试从自己的mcache0中获取，如果mcache0中没有需要的对象，则会去central heap或span中获取。由于mcache0中只储存了一些常用的小heap对象，因此能够快速响应请求，提高了程序的响应速度。

作为mcache的基础

当一个goroutine第一次请求分配heap对象时，它会被创建一个新的mcache，并被赋值给mcache0。这样，mcache0变成了该goroutine的本地缓存，之后mcache0的所有操作都基于这个mcache，因此mcache0也可以看做是mcache的基础。

综上所述，mcache0作为当前goroutine的本地缓存，可以提高程序的响应速度。作为heap对象的分配源，它可以在不同的goroutine之间共享内存，从而提高了程序的并发性能。作为mcache的基础，它使得mcache能够在不同的goroutine之间共享内存，进一步增加了程序的并发性能。

raceprocctx0

raceprocctx0 是一个指向 GC 阶段使用的对象的指针。GC 阶段是 Go 程序中的垃圾回收阶段，其目的是在运行时通过标记和清除无用对象来释放内存并避免内存泄漏。

在 Go 程序中，raceprocctx0 用于在运行时检查内存访问的竞争条件。竞争条件指的是多个并发线程同时访问相同的共享资源，并且该资源的最终结果取决于这些线程的交替执行方式。在 raceprocctx0 变量中存储了 pthread_mutex_t 结构指针，用于保护并发访问的共享内存区域，避免竞争条件的发生。

具体来说，在 Go 程序运行时，runtime 包会利用 raceprocctx0 变量来跟踪每个并发线程的访问情况，并记录下潜在的竞争条件。如果程序中存在竞争条件，则会在运行时输出相关的错误信息，以提醒开发人员尽快解决问题。

总之，raceprocctx0 变量在 Go 程序的并发调试和优化中起到了重要的作用，它能够帮助开发人员快速发现并解决可能导致竞争条件的代码，提高程序的并发性能和稳定性。

raceFiniLock

在Go语言中，raceFiniLock是用来保护内存竞争检测工具在程序退出时清理内存的锁。

当程序结束时，Go语言的运行时会调用racefini函数来做一些清理工作。在racefini函数中，会先获取raceFiniLock锁，然后扫描当前程序是否存在内存竞争。如果存在内存竞争，则会输出相应的警告信息，否则就直接释放锁并退出。

这个锁的作用是保证多个goroutine在程序结束时对内存竞争检测工具进行清理时不会互相干扰。如果没有raceFiniLock锁，多个goroutine会同时尝试清除内存竞争检测工具的状态，导致竞争条件的发生。

总之，raceFiniLock的作用是在程序退出时保证对内存竞争检测工具进行清理时的并发安全。

runtime_inittasks

在 Go 中，runtime_inittasks 是一个包级别变量。它的作用是保存一些需要在 Go 程序启动时执行的任务，例如启动 goroutine 和执行 finalizer 等。

当 Go 程序启动时，runtime 包会按照注册的顺序执行 runtime_inittasks 中的任务。这些任务会在程序的 main 函数执行之前完成。其中包括启动每个处理器上的 m （m:n 调度的 m）以及调度 goroutine。这些任务的执行过程是高度优化的，以减少启动时间和占用资源。

另外，runtime_inittasks 还包含了一些内置函数的注册，例如 go/defer 等，确保它们能够在 Go 程序的启动时进行初始化。这些内置函数的注册也是通过 runtime 包完成的。

总之，runtime_inittasks 的作用是在 Go 程序开始执行前初始化运行时环境，准备好程序运行所必须的资源，包括启动 goroutine 和执行内置函数注册等任务。

main_init_done

main_init_done是一个布尔型变量，用于标记Go程序中init和main函数是否已经执行完成。在Go程序启动时，会先执行主 goroutine 中的init函数，然后执行main函数来启动程序。

main_init_done变量的作用是确保所有的init函数都执行完毕以后才去执行main函数。这个变量会在所有的init函数执行完毕后被设置为true，然后在调用main函数之前进行检查。如果main_init_done为false，则让程序进入休眠，等待所有的init函数执行完毕后再执行main函数。

这个变量的作用是为了保证程序的正确性和稳定性。如果某个包的init函数依赖于另一个包的函数，并且这个包的init函数还没有执行完成，那么调用该包的函数将会导致未定义的行为。因此，需要等待所有的init函数执行完毕以后再执行main函数，以确保程序的正确性。

mainStarted

mainStarted是一个用来表示程序是否已经开始执行主函数的布尔变量。它被定义在runtime/proc.go文件中，并且只有在main函数被调用时才会被设置为true。

在Go语言中，程序的入口点是main函数。当程序启动时，Go运行时会创建一个主goroutine，并调用main函数。mainStarted这个变量的作用就是用来记录这个过程是否已经发生。

在某些情况下，程序可能不会调用main函数，例如在编译时使用-buildmode=c-shared选项，或者使用Cgo调用Go代码时。在这种情况下，mainStarted变量会被设置为false，并且一些与main函数相关的操作会被跳过。

此外，在程序运行过程中，mainStarted还可以用来进行一些状态检查，例如在崩溃时打印调用栈信息时，就会检查mainStarted的值来决定是否打印main goroutine的调用栈。

runtimeInitTime

在Go语言中，proc.go是一个非常重要的文件，它定义了一些与协程（goroutine）和操作系统线程（OS Thread）相关的操作。其中，runtimeInitTime是定义在proc.go文件中的一个变量，它的作用是记录程序启动时间。

具体来说，当Go程序启动时，runtime会在proc.go文件中初始化runtimeInitTime变量，通过调用monotonicNow()函数获取当前时间的纳秒数，将其赋值给runtimeInitTime变量。此后，程序中的其他模块可以通过访问proc.go中的runtimeInitTime变量，获取程序的启动时间。

需要注意的是，runtimeInitTime变量并不是线程安全的，因此在多线程环境下，使用时需要进行同步处理。

为什么要记录程序启动时间呢？这是因为程序的运行时间、错误日志等功能都需要依赖此信息。例如，在处理错误日志时，可以将日志中的时间戳与程序启动时间相减，得到相对时间，从而更好地了解错误发生的时间和顺序。

initSigmask

initSigmask是一个全局变量，类型为sigset，它的作用是初始化进程的信号掩码。

在操作系统中，信号掩码指的是进程要屏蔽或忽略的信号集合。在Go语言中，进程的信号掩码被封装为一个由sigaltstack，sigmask和sigignore三个变量组成的结构体sigctxt。其中，sigaltstack是用于备用信号栈的栈结构体，sigmask是进程的信号掩码，sigignore是要忽略的信号集合。

而initSigmask是在runtime包初始化时，调用函数initSigmask()初始化的。这个函数会从内核获取当前进程的信号掩码，然后把所有信号都添加到信号掩码中（除了SIGPROF和SIGVTALRM，因为这两个信号在后面的处理器监控中会用到），并将这个信号掩码设置为进程的全局掩码。

这样做的目的有两个：一是为了避免信号处理器在没有显式设置信号掩码的情况下阻止与程序的主要逻辑并发进行；二是确保一个新线程从开始时就处于一个干净的、与主线程相同的进程信号掩码状态下（因为新线程会在全局信号掩码上创建自己的信号掩码）。

总之，initSigmask的作用是为进程设置全局信号掩码，以确保进程在没有显式信号掩码设置的情况下保持正常运行。

allglock

在Go语言中，glock（全称为golang global lock）是一种用于维护并发控制的机制，用于保证在多线程下 Go 的共享资源能够被正确地访问和修改。glock 是 Go runtime 的核心组件之一，它在运行时来确保安全访问和修改共享资源。

allglock 变量的作用是记录运行时中所有的 glock，以便能够在调用 allglockunlock() 时，遍历所有的 glock 锁，将其解锁，进而保证共享资源的安全访问和修改。

allglock 变量定义在 proc.go 文件中，是 Go runtime 中一个 Go 辅助宏，该宏用于获取所有的 glock，并将其从内核中解锁，从而实现安全访问和修改共享资源的目标。

通过 allglock 变量，Go runtime 能够解锁不同的 glock 并存储在不同的信号处理器中，从而确保在不同的场景下共享资源的安全访问和修改。

allgs

allgs是一个全局变量，定义在proc.go这个文件中。它是一个指向所有G（goroutine）的切片的指针。G是Go语言中的协程，是实现并发的基本单元。allgs的作用是跟踪所有的goroutine，用于调试和监控。

具体来说，allgs的作用有以下几个方面：

Debugging：allgs变量可用于调试Go程序。通过打印切片中的所有元素，可以查看当前正在运行的所有goroutine的堆栈跟踪信息，以及它们的状态、调度情况等信息。
Garbage Collection（垃圾回收）：垃圾回收器需要跟踪所有的goroutine以了解它们是否还在运行。allgs变量在垃圾回收期间用于遍历所有的goroutine，并标记它们的栈。
Runtime Statistics（运行时统计）：allgs变量还用于收集关于运行时的统计信息。例如，可以计算运行时同时存在的最大goroutine数量、goroutine数量的平均值等等。

总之，allgs变量在Go语言的运行时系统中扮演着重要的角色，用于跟踪所有的goroutine，为调试、垃圾回收和运行时统计等提供支持。

allglen

在Go语言中，allglen是一个全局变量，用于记录g（goroutine）的数量。在proc.go文件中，allglen的值是在create和freem函数中进行更新的。

create函数在每次创建一个新的goroutine时会将allglen加1，而freem函数在释放goroutine所占用的内存时会将allglen减1。

此外，allglen在垃圾回收过程中也扮演着重要的角色。在进行垃圾回收时，如果allglen的值超过了最大值，垃圾回收器就会暂停程序的执行，等待所有活跃的goroutine都进入休眠状态后再继续进行垃圾回收。这样可以保证垃圾回收器能够有效地回收所有不再使用的内存。

总之，allglen变量在Go语言运行时系统中扮演着非常重要的角色，可以帮助管理goroutine的创建，释放和垃圾回收，从而确保程序的运行效率和稳定性。

allgptr

在Go语言中，allgptr变量是一个指向所有goroutine的指针数组。allgptr数组中的每个元素都指向一个g结构体，该结构体表示一个goroutine的状态信息。

allgptr变量的作用很重要。Go语言中的goroutine是一个轻量级的线程，运行时会根据goroutine数量动态地调整线程池中的线程数。每个goroutine都会被封装为一个g结构体，在运行时会被加入到allgptr数组中。在处理系统监控、诊断和调试等功能时，我们需要遍历所有的goroutine，获取它们的状态信息。这时，allgptr变量就派上用场了。我们只需要遍历allgptr数组，就可以获取所有goroutine的状态信息。

除此之外，allgptr变量还可以被用于goroutine的垃圾回收。在Go语言中，当一个goroutine结束时，它的g结构体并不会立即被销毁。相反，它会被放入一个专门的goroutine垃圾回收链表中。当这个链表达到一定长度时，Go运行时会触发goroutine的垃圾回收，将未使用的g结构体回收起来，以减少内存的使用。

总之，allgptr变量是Go语言中非常重要的一个变量，它主要用于管理和监控所有的goroutine。对于Go语言开发者来说，理解allgptr变量的作用，可以帮助我们更好地理解Go语言的运行机制，提高开发效率和程序质量。

fastrandseed

在 Go 语言中，fastrandseed 变量是用于产生随机数的种子。这个种子有以下几个作用：

用于生成随机数：当需要生成随机数时，可以使用该种子作为随机数生成器的种子，让每次生成的数值都有一定的随机性，避免出现预测性的结果。
避免重复生成相同的随机数序列：如果多次需要生成随机数，使用不同的种子可以避免重复生成相同的随机数序列，增加随机性。

在 proc.go 文件中的实现中，fastrandseed 变量的类型为 uint32，表示一个 32 位的非负整数。每次生成随机数时，都会使用 fastrandseed 变量作为随机数生成器的种子，生成一个新的随机数，并将新的种子放回 fastrandseed 变量中，以备下次使用。

总之，fastrandseed 变量的作用是提供种子来产生随机性，从而帮助程序生成随机数和增加可预测性。

freezing

在Go语言运行时的proc.go文件中，freezing是一个布尔变量，它用于控制是否冻结住一个或多个P（Processing Element）。

当一个Goroutine（Go语言中的轻量级线程）需要执行时，它会尝试获取一个P来运行。如果没有空闲的P，那么Goroutine可能会阻塞，直到有一个P可用。

但是，如果系统中所有的P都被占用，并且没有新的P可以被创建（在某些情况下，必须限制P的数量），这意味着系统可能会陷入死锁状态。为了避免这种情况发生，Go语言运行时引入了冻结的概念。

当一个P被冻结时，该P可以被系统视为不存在，其他Goroutines不会将其视为可用的P。这样，当所有的P都被冻结时，Goroutines不会阻塞，系统也不会陷入死锁状态。

在proc.go文件中，如果freezing被设置为true，则表示正在冻结P。这时，不再向任何P发送新的Goroutine，并将所有正在运行的Goroutine移动到单独的队列中，以等待P可用时再次运行。同时，如果系统中已有所有P处于自由状态，但需要继续冻结P，则会将其中一个P设置为自由状态，并将其冻结，以保证其他Goroutines可以继续执行。

从以上介绍可以看出，freezing变量对于保证Go语言程序的稳定运行非常重要。通过控制P的数量，以及在需要时使P处于冻结状态，可以避免系统陷入死锁状态，最终保障应用程序的稳定性和可用性。

casgstatusAlwaysTrack

casgstatusAlwaysTrack变量的作用是在goroutine中跟踪CAS的状态，以确保在CAS操作期间其他线程不会修改被操作的内存值。在某些情况下，需要在CAS时始终跟踪状态，因为在复杂的内存模型中，通过检查组合的访问模式，可以使用优化的同步操作来更好地避免性能瓶颈。

在Go运行时中，当某个goroutine正在执行一个CAS操作时，可以通过将casgstatusAlwaysTrack设为true来始终跟踪状态。这意味着运行时会记录所有内存访问并检查它们是否与CAS操作相关。如果内存访问与操作相关，则运行时会自动插入内存屏障来阻止其他goroutine对内存进行修改。

casgstatusAlwaysTrack变量是一个全局变量，它被用于全局运行时状态。默认情况下，该变量为false，只有在必要时才设置为true来启用CAS状态跟踪。

worldsema

worldsema是一个全局信号量，用于控制调度器中世界（Goroutines）的开启和关闭。每个世界在进入系统调用时都必须获取该信号量的锁，因为在进行系统调用期间，调度器可能会关闭它的线程M并停止调度该世界，直到该系统调用返回。获取锁表示该世界已经准备好进行系统调用并将线程M暂时释放给其他世界使用，同样地，当一个世界从一个系统调用返回时，它必须释放这个锁，以便其他世界可以获取它进行系统调用。该锁的目的是保持调度器的正确性和稳定性，避免因上述问题而导致死锁或其他问题。

总之，worldsema是一个非常重要的全局信号量，它确保了调度器的正确性和稳定性，避免了死锁和其他问题。

gcsema

在Go语言的运行时(runtime)中，gcsema是一个用于实现垃圾回收机制的信号量(semaphore)变量。它的作用是控制并发的垃圾回收，以避免多个线程同时触发垃圾回收而导致的性能问题。

具体来说，当某个线程需要触发垃圾回收时，它会尝试获取gcsema信号量（通过调用runtime.semacquire函数）。如果gcsema的值为0，说明当前没有其他线程正在进行垃圾回收，这个线程可以安全地开始垃圾回收操作。如果gcsema的值不为0，则说明其他线程正在进行垃圾回收，这个线程需要等待（通过调用runtime.semrelease函数释放gcsema信号量的线程进行唤醒）。

在垃圾回收完成后，gcsema的值会被设置为0，其他等待的线程会被唤醒，然后再次尝试获取gcsema信号量。

通过使用gcsema信号量控制并发的垃圾回收，Go语言的运行时系统可以实现高效、安全的垃圾回收操作，从而保证程序的稳定性和性能。

cgoThreadStart

在Go语言中，cgo是用来调用C语言函数的机制。在运行时(runtime)中，cgoThreadStart是一个变量，它用来标识go程序中每个C语言线程的执行函数。cgoThreadStart的类型是一个函数指针，它指向一个C语言函数。当一个新的C语言线程被创建时，Go调度器会调用cgoThreadStart来执行这个线程。

具体来说，在C语言中，线程需要一个入口函数来启动。这个入口函数需要指定一个函数指针，它指向实际的线程执行函数。在Go语言中，cgoThreadStart就是这个线程入口函数的函数指针。当Go语言程序需要调用C语言线程时，会把cgoThreadStart指针作为参数传递给C语言库。C语言库用cgoThreadStart来启动线程，并执行线程中的代码。

需要注意的是，cgoThreadStart不是所有平台都存在的。在一些平台上，比如ARM和MIPS等嵌入式平台，没有标准的C语言线程模型。因此，在这些平台上，Go语言使用自己的协程调度器来代替C语言线程。这时，cgoThreadStart就被设置为nil，因为不再需要它来启动C语言线程。

extram

在 Go 的运行时中，extram 变量是一个指向描述额外内存的结构体的指针。该结构体用于存储运行时分配的不在堆上的大量内存的信息，例如在调用 LargeAlloc 函数时分配的内存。extram 变量的初始化和使用发生在 procresize、sysAlloc 和 sysFree 函数中。

extram 变量的主要作用是维护并跟踪运行时中大量额外内存的使用情况。这些额外的内存需要与堆内部的分配和释放操作区分开来，因为它们的大小可能非常巨大，堆不适合管理它们。

extram 变量以链表形式维护所有被分配的额外内存的块。在调用 LargeAlloc 函数时，它会从 extram 变量中分配一个块来存储分配的内存。在释放内存时，它会遍历所有的额外内存块，并将指定的内存块从链表中删除。

总之，extram 变量扮演着 Go 运行时中维护额外内存的关键角色，帮助跟踪和管理未在堆中分配的大量内存块，确保它们被正确地分配和释放。

extraMCount

extraMCount是在Go语言运行时系统中用于控制M（Machine）数量的变量。

在Go语言中，M是执行Go代码的执行单元。每个M都有一个或多个G（Goroutines）绑定在其上，G是独立执行的轻量级线程。M的数量会根据当前系统的负载情况而动态变化，用于提高程序的并发性和并行性。

extraMCount变量的作用是在M的数量已经被调整到合适的水平后，再额外增加一定数量的M。这些额外的M可以用于处理突发性的任务负载，提高程序的响应能力和性能。

具体来说，extraMCount的值在每次进行M数量调整时被考虑。如果extraMCount的值为正数，则会额外创建该数量的M。如果extraMCount的值为负数，则会尝试销毁该数量的M。在进行M数量调整后，extraMCount的值会被重置为零。

extraMCount变量通常由程序员在调用runtime.GOMAXPROCS函数时指定。默认情况下，extraMCount的值为0，即不会额外创建M。

总之，extraMCount变量是Go语言运行时系统中一个用于控制M数量的重要参数，可以用于优化程序的并发性能。

extraMWaiters

extraMWaiters是一个全局变量，是用于存储额外的等待线程（waiter）的队列。

在Go程序中，当有goroutine等待一些资源（例如锁或信号量）时，它们会进入等待状态，并被阻止执行下一步指令，直到资源可用。为了提高系统的并发性能，在等待时可以将运行时中的M（机器线程）返回给系统，让系统可以调度其他M执行其他任务。但是，有些情况下，系统没有足够的可用M来执行其他任务，例如在高负载情况下，所有的M都在执行。在这种情况下，就需要使用extraMWaiters来保存所有被阻塞的线程信息，等待下一次有可用M时，再被唤醒并继续执行。

通常情况下，extraMWaiters并不会直接被程序所使用，而是会被runtime中的其他组件来管理。例如，在等待内核锁时如果没有其他可用的M，则goroutine将被加入extraMWaiters队列。当同一资源的锁被解开时，这个队列中的所有线程都将被唤醒并重新竞争锁的获取。由于extraMWaiters被设计为在高负载环境下和竞争条件下使用，因此该变量的实现需要强制调度，从而提高竞争时唤醒等待线程的准确度。

allocmLock

在 Go 的 runtime 中，allocmLock 这个变量是用来保护内存分配的锁。具体来说，它是一个互斥锁，用于保护 allocm 函数的并发执行。

allocm 函数是用来为某个 Go 协程分配 goroutine M（machine 的简称，是一个执行 Go 代码的线程）和 P（processor 的简称，是一组 M 的集合，由 sched、work、gc 和 sysmon 四个部分使用）的。在进行内存分配时，需要对内存分配器进行加锁，以防止多个协程同时进行内存分配时发生竞争问题。

因此，allocmLock 这个互斥锁的作用就是保护了 allocm 函数的访问，确保它在任何时候只有一个协程在执行。这样可以避免竞争条件，保证内存分配器的正确性和稳定性。

execLock

在 Go 语言运行时的 go/src/runtime 目录中，proc.go 文件主要包含了实现与 Goroutine 和操作系统线程相关的代码。其中，execLock 变量是一个用于保护操作系统执行 Goroutine 的互斥锁。

为了保证 Goroutine 的正确执行，Go 运行时需要向操作系统申请创建线程或分配 CPU 资源，这些操作需要在并发环境中执行。为了防止多个 Goroutine 同时尝试操作操作系统资源，导致数据竞争和不可控行为，Go 运行时中使用了 execLock 变量来控制对操作系统执行的访问。

execLock 是一个 Mutex 类型的变量，在执行 Goroutine 时，首先会通过此锁来进行保护。在每次需要向操作系统请求线程资源时，都需要先持有 execLock 锁，以保证同一时间只有一个 Goroutine 在执行请求操作。当一个 Goroutine 请求操作系统资源时，如果发现 execLock 已经被其他 Goroutine 持有，则会阻塞等待 execLock 锁的释放。

这样，通过控制对操作系统执行的访问，execLock 可以避免多个 Goroutine 同时请求操作系统资源，避免了数据竞争和不可控行为，保证了 Goroutine 的正确执行。

newmHandoff

newmHandoff是一个用于协程（Goroutine）调度的变量，在Go语言的运行时（Runtime）中的proc.go文件中。

当一个新的协程被创建后，它需要有一个可用的处理器（Processor）来执行它。这时候就需要用到newmHandoff。当一个处理器没有可用的协程时，它会阻塞在newmHandoff上，等待新的协程的到来。

当新的协程被创建出来时，它会被放置在一个全局的等待队列中。然后处理器从等待队列中获取一个协程，并将它绑定到处理器上执行。同时，如果等待队列中还有其他协程，则处理器会将自己添加到newmHandoff等待队列中，等待另一个空闲的处理器去执行其他协程。

总之，newmHandoff是一个重要的变量，它在运行时中扮演着协程调度的重要角色，确保新创建的协程能够被及时地执行。

inForkedChild

在Go语言中，proc.go文件是runtime包中的一部分，主要用于启动和管理Goroutines。inForkedChild是proc.go文件中的一个布尔变量，用于指示当前进程是否是在fork子进程中。其作用如下：

用于跟踪当前进程的状态。当inForkedChild为true时，表示当前进程是在fork子进程中。而当inForkedChild为false时，则表示当前进程不是在fork子进程中。
用于处理在fork子进程中的情况。在启动新的Goroutine时，会根据当前进程是否在fork子进程中以及所在的操作系统不同，采用不同的逻辑进行处理，以保证在所有情况下都能正确地启动新的Goroutine。
用于保证程序的稳定性。由于fork子进程会创建一个新的进程，因此在子进程中启动新的Goroutine时，可能会导致一些不可预知的问题。通过使用inForkedChild变量，可以保证程序在fork子进程中运行时的稳定性，避免出现异常情况。

总之，在proc.go文件中，inForkedChild变量是一个非常重要的变量，它的作用是跟踪当前进程的状态，并根据不同的情况采用不同的逻辑进行处理，保证程序能够在所有情况下都能正确地启动和管理Goroutines。

pendingPreemptSignals

在Go语言的并发编程中，Goroutine是一个独立的工作单元，它可以由Go语言的调度器在不同的线程之间进行调度。在Goroutine运行的过程中，可能会出现需要强制调度的情况，比如在系统中有更高优先级的任务需要处理时，或者Goroutine自身在执行过程中已经耗费了很长时间但仍未结束。

为了应对这些情况，Go语言的调度器实现了一种基于抢占式调度的机制。当调度器需要强制终止一个正在执行的Goroutine时，它会向该Goroutine发送一个preempt信号，然后等待一段时间，如果该Goroutine在这段时间内没有进行一些必要的操作，比如调用系统调用等，那么调度器就会直接将该Goroutine强制终止。

pendingPreemptSignals变量就是用来记录当前系统中发送到Goroutine中待处理的preempt信号的数量的变量。在Go语言中，每一个Goroutine都有一个能够响应preempt信号的挂起点，只有当Goroutine遇到这个挂起点时，它才会停下来，并且响应preempt信号。而在Goroutine没有遇到这个挂起点的情况下，它会一直执行下去，从而导致preempt信号无法得到及时的响应。

因此，pendingPreemptSignals变量的作用就是用来记录那些已经被发送到Goroutine中但是还未被响应的preempt信号的数量，它会在调度器开始一个新的调度循环时被重置为0，当调度器向某个Goroutine发送一个preempt信号时，就会将pendingPreemptSignals加1，当Goroutine响应preempt信号时，就会将pendingPreemptSignals减1，直到pendingPreemptSignals变量的值为0，调度器才会退出调度循环，从而结束强制调度的过程。