Go / 系统课时

理解系统调用与线程阻塞

理解系统调用与线程阻塞

本课解决一个常见误区:某个 Goroutine 卡在阻塞系统调用时,并不意味着整个 Go 程序都停住。你将理解 G、M、P 在进入与退出系统调用时如何重新组合,从而判断阻塞是否真的压住了其他 Goroutine。

学习目标

  • 理解 Goroutine 进入阻塞系统调用后的 G、M、P 状态变化
  • 能解释为什么 GOMAXPROCS=1 时其他 Goroutine 仍可继续执行
  • 能用一个最小实验观察阻塞与恢复过程

系统调用为什么不会直接卡住整个调度器

Go 调度器可以把 G 看成待执行的 Goroutine,把 M 看成操作系统线程,把 P 看成执行 Go 代码所需的调度资源。一个 M 在执行普通 Go 代码时,需要同时持有一个 P;而 M 进入阻塞系统调用后,运行时会让出这个 P,使它可以被其他 M 使用。:contentReference[oaicite:0]{index=0}

因此,“线程正在阻塞”与“P 被永久占住”不是同一件事。真正重要的是阻塞的 M 是否已经释放 P,以及运行时能否让另一个 M 接手继续执行可运行的 G。

系统调用阻塞时 G、M、P 的调度关系

进入阻塞系统调用时发生了什么

可以把过程压缩成四个关键动作。首先,正在运行的 G 发起系统调用;然后它进入 _Gsyscall 状态,当前 M 不再继续执行普通 Go 代码;运行时把对应的 P 交还给空闲 P 池;最后,另一个 M 可以拿到 P,继续执行队列中的其他 G。:contentReference[oaicite:1]{index=1}

系统调用返回后,原来的 M 需要再次获得一个 P 才能继续执行 Go 代码。如果此时没有立即可用的 P,运行时不会为了“还原原线程”而停住其他工作,而是让这个 G 等待调度,直到获得执行资源。

这里最容易混淆的是:M 的数量可以暂时多于 P 的数量。原因之一就是部分 M 可能正在执行系统调用或 C 调用;P 的数量才对应 Go 代码可以同时推进的并行执行度。

用一个阻塞读实验验证

下面的程序把 GOMAXPROCS 固定为 1,让一个 Goroutine 在管道读取上阻塞,同时另一个 Goroutine 每隔一段时间打印一次。写端延迟一小段时间后写入数据,唤醒阻塞的读取。

go
package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	old := runtime.GOMAXPROCS(1)
	defer runtime.GOMAXPROCS(old)

	r, w := runtime.PipeForDemo()
	defer r.Close()
	defer w.Close()

	done := make(chan struct{})

	go func() {
		buf := make([]byte, 1)
		fmt.Println("reader: waiting for data")
		_, err := r.Read(buf)
		if err != nil {
			panic(err)
		}
		fmt.Println("reader: received data")
		close(done)
	}()

	go func() {
		ticker := time.NewTicker(100 * time.Millisecond)
		defer ticker.Stop()
		for i := 0; i < 3; i++ {
			<-ticker.C
			fmt.Println("worker: running")
		}
	}()

	time.Sleep(350 * time.Millisecond)
	fmt.Fprint(w, "x")
	<-done
}

上面的 runtime.PipeForDemo 并不存在,因此它是用于说明结构的片段示例,不能直接运行。要进行真实验证,应使用平台提供的 os.Pipe:

go
package main

import (
	"fmt"
	"os"
	"runtime"
	"time"
)

func main() {
	runtime.GOMAXPROCS(1)
	r, w, err := os.Pipe()
	if err != nil {
		panic(err)
	}
	defer r.Close()
	defer w.Close()

	done := make(chan struct{})

	go func() {
		buf := make([]byte, 1)
		fmt.Println("reader: waiting")
		if _, err := r.Read(buf); err != nil {
			panic(err)
		}
		fmt.Println("reader: received")
		close(done)
	}()

	go func() {
		for i := 1; i <= 3; i++ {
			time.Sleep(100 * time.Millisecond)
			fmt.Printf("worker: tick %d\n", i)
		}
	}()

	time.Sleep(350 * time.Millisecond)
	if _, err := w.Write([]byte{'x'}); err != nil {
		panic(err)
	}
	<-done
}

预期输出

text
reader: waiting
worker: tick 1
worker: tick 2
worker: tick 3
reader: received

具体行间时序可能略有变化,但关键结果应保持一致:reader 阻塞期间,worker 仍然获得执行机会。这个实验说明 GOMAXPROCS=1 并不等于“程序只能存在一个线程”,也不等于“一个阻塞系统调用会冻结所有 Goroutine”。

哪些阻塞值得继续追查

并不是所有等待都属于同一种调度路径。一个 Goroutine 可能阻塞在系统调用、网络等待、同步原语、运行时等待或用户代码中的长时间计算上。分析问题时,应先确认它到底在等待什么,而不是看到线程数增加就直接判断“线程泄漏”。

尤其要区分两类现象:阻塞 M 增多,但其他 G 仍能正常运行,通常说明运行时正在为阻塞工作增加或调度其他执行线程;而大量 G 都不可运行,或可运行 G 长时间得不到 P,才更值得沿调度延迟、CPU 饱和和锁竞争继续追查。

生产排障时还应关注 GODEBUG=schedtrace=<TIME> 等调度观测信息。Go 官方性能文档说明,这类输出可以观察 gomaxprocs、空闲 P、线程以及运行队列长度,从而帮助判断到底是 Goroutine 缺乏执行资源,还是大量线程正在做系统调用。:contentReference[oaicite:2]{index=2}

理解这一点后,看到“系统调用阻塞导致线程被占住”时,就不应直接推导成“Go 调度器被卡住”。正确的判断单位是 G、M、P 三者的状态变化:阻塞可以发生在单个执行路径上,但运行时会尽力把可用 P 交给仍然能够运行的 Goroutine。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

理解系统调用与线程阻塞

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通