深入理解Go调度器：G 的创建（二）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// src/runtime/runtime2.go
type g struct {
	// 当前 goroutine 的栈内存范围
	stack       stack   // offset known to runtime/cgo
	stackguard0 uintptr // offset known to liblink
	stackguard1 uintptr // offset known to liblink

	_panic    *_panic // g 中 panic 相关的处理
	_defer    *_defer // g 中 defer 相关的处理
	m         *m      // 当前 g 绑定的 m
	sched     gobuf   // 存储当前 g 调度相关的数据，上下文切换时会把当前信息保存到这里
  // g 发生系统调用相关的参数
	syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc
	syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc
	stktopsp  uintptr // expected sp at top of stack, to check in traceback
	// param is a generic pointer parameter field used to pass
	// values in particular contexts where other storage for the
	// parameter would be difficult to find. It is currently used
	// in three ways:
	// 1. When a channel operation wakes up a blocked goroutine, it sets param to
	//    point to the sudog of the completed blocking operation.
	// 2. By gcAssistAlloc1 to signal back to its caller that the goroutine completed
	//    the GC cycle. It is unsafe to do so in any other way, because the goroutine's
	//    stack may have moved in the meantime.
	// 3. By debugCallWrap to pass parameters to a new goroutine because allocating a
	//    closure in the runtime is forbidden.
	param        unsafe.Pointer
	atomicstatus atomic.Uint32 // g 的状态
	stackLock    uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
	goid         uint64    // g 的 id
  ......
}

1
2

1. 优先放在 p.runnext 上，如果 p.runnext 不为空，用新 G 替换原来的 G;
2. 原来的 G 放到 p.runq 上，如果 p.runq 队列满了，则将 p.runq 的一半（从头部开始取）移到全局队列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// src/runtime/proc.go#L4238
// Create a new g running fn.
// 创建一个新的 g，运行 fn 函数
// 将其放在 g 队列，等待运行
// 编译器会将 go 关键字的语句转化成此函数
func newproc(fn *funcval) {
	gp := getg()
	pc := getcallerpc()
	systemstack(func() {
		newg := newproc1(fn, gp, pc)

		pp := getg().m.p.ptr()
		runqput(pp, newg, true)  // next == true, 保证新 g 优先放在 p.runnext 上
		// main goroutine 创建的时候，立即唤醒p
		if mainStarted {
			wakep()
		}
	})
}

1
2
3
4
5
6

	newg := gfget(pp)
	if newg == nil {
		newg = malg(_StackMin)  // _StackMin
		casgstatus(newg, _Gidle, _Gdead)
		allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// src/runtime/proc.go#L4384
// Put on gfree list.
// If local list is too long, transfer a batch to the global list.
func gfput(pp *p, gp *g) {
  // G 状态检查
	if readgstatus(gp) != _Gdead {
		throw("gfput: bad status (not Gdead)")
	}
	// G 的栈内存检查，如果不是标准栈大小，释放栈空间
	stksize := gp.stack.hi - gp.stack.lo

	if stksize != uintptr(startingStackSize) {
		// non-standard stack size - free it.
		stackfree(gp.stack)
		gp.stack.lo = 0
		gp.stack.hi = 0
		gp.stackguard0 = 0
	}
	// 放入 p.gFree 列表, 如果列表中g个数超过64，仅会在P本地列表保存32个，超过的部分放到全局空闲列表
	pp.gFree.push(gp)
	pp.gFree.n++
	if pp.gFree.n >= 64 {
		var (
			inc      int32
			stackQ   gQueue
			noStackQ gQueue
		)
		for pp.gFree.n >= 32 {
			gp := pp.gFree.pop()
			pp.gFree.n--
			if gp.stack.lo == 0 {
				noStackQ.push(gp)
			} else {
				stackQ.push(gp)
			}
			inc++
		}
		lock(&sched.gFree.lock)
		sched.gFree.noStack.pushAll(noStackQ)
		sched.gFree.stack.pushAll(stackQ)
		sched.gFree.n += inc
		unlock(&sched.gFree.lock)
	}
}

1
2
3
4

type m struct {
	g0      *g     // g0主要用来记录工作线程使用的栈信息，在执行调度代码时使用g0
  ...
}

1
2
3
4
5
6

// src/runtime/proc.go#L113
var (
	m0           m
	g0           g
  ......
)

1
2
3
4
5
6

	newg := gfget(pp)
	if newg == nil {
		newg = malg(_StackMin)  // _StackMin
		casgstatus(newg, _Gidle, _Gdead)
		allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
	}