GO goroutine状态流转

于 2024-08-01 22:42:20 发布
阅读量708 收藏 12
点赞数 19
分类专栏： lang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iUcool/article/details/140859279
版权

在这里插入图片描述

Gidle -> Grunnable

newproc获取新的goroutine，并放置到P运行队列中

这也是go关键字之后实际编译调用的方法

func newproc(fn *funcval) {
  // 获取当前正在运行中的goroutine
	gp := getg()
  // 获取调用者的程序计数器地址，用于调试和跟踪
	pc := getcallerpc()
	systemstack(func() {
    // 创建一个新的 goroutine 并返回新创建的 goroutine 结构 newg
		newg := newproc1(fn, gp, pc)

    // 获取当前P，并将新创建的goroutine放到P的运行队列中
		pp := getg().m.p.ptr()
		runqput(pp, newg, true)

    // 如果主 goroutine 已经启动（mainStarted 为 true），则调用 wakep() 唤醒或启动一个处理器以执行运行队列中的 goroutine
		if mainStarted {
			wakep()
		}
	})
}

newproc1用于获取新的goroutine

// Create a new g in state _Grunnable, starting at fn. callerpc is the
// address of the go statement that created this. The caller is responsible
// for adding the new g to the scheduler.
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
	if fn == nil {
		fatal("go of nil func value")
	}

	mp := acquirem() // disable preemption because we hold M and P in local vars.
	pp := mp.p.ptr()
  // 首先从P的gfree获取回收的g，如果没有，那么再从全局调度器sched中gfree窃取给P，再不然就只能调用malg()新建g
	newg := gfget(pp)
	if newg == nil {
		newg = malg(stackMin)
		casgstatus(newg, _Gidle, _Gdead)
		allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
	}
	if newg.stack.hi == 0 {
		throw("newproc1: newg missing stack")
	}

	if readgstatus(newg) != _Gdead {
		throw("newproc1: new g is not Gdead")
	}

  // 计算和分配堆栈指针
	totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) // extra space in case of reads slightly beyond frame
	totalSize = alignUp(totalSize, sys.StackAlign)
	sp := newg.stack.hi - totalSize
	if usesLR {
		// caller's LR
		*(*uintptr)(unsafe.Pointer(sp)) = 0
		prepGoExitFrame(sp)
	}
	if GOARCH == "arm64" {
		// caller's FP
		*(*uintptr)(unsafe.Pointer(sp - goarch.PtrSize)) = 0
	}

  // 初始化调用帧
	memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
	newg.sched.sp = sp
	newg.stktopsp = sp
	newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
	newg.sched.g = guintptr(unsafe.Pointer(newg))
	gostartcallfn(&newg.sched, fn)
  
  // 设置新G元数据
	newg.parentGoid = callergp.goid
	newg.gopc = callerpc
	newg.ancestors = saveAncestors(callergp)
	newg.startpc = fn.fn
	if isSystemGoroutine(newg, false) {
		sched.ngsys.Add(1)
	} else {
		// Only user goroutines inherit pprof labels.
		if mp.curg != nil {
			newg.labels = mp.curg.labels
		}
		if goroutineProfile.active {
			// A concurrent goroutine profile is running. It should include
			// exactly the set of goroutines that were alive when the goroutine
			// profiler first stopped the world. That does not include newg, so
			// mark it as not needing a profile before transitioning it from
			// _Gdead.
			newg.goroutineProfiled.Store(goroutineProfileSatisfied)
		}
	}
	// Track initial transition?
	newg.trackingSeq = uint8(cheaprand())
	if newg.trackingSeq%gTrackingPeriod == 0 {
		newg.tracking = true
	}
	gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))

	// Get a goid and switch to runnable. Make all this atomic to the tracer.
  // 分配gid，并更新状态为_Grunnable
	trace := traceAcquire()
	casgstatus(newg, _Gdead, _Grunnable)
	if pp.goidcache == pp.goidcacheend {
		// Sched.goidgen is the last allocated id,
		// this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
		// At startup sched.goidgen=0, so main goroutine receives goid=1.
		pp.goidcache = sched.goidgen.Add(_GoidCacheBatch)
		pp.goidcache -= _GoidCacheBatch - 1
		pp.goidcacheend = pp.goidcache + _GoidCacheBatch
	}
	newg.goid = pp.goidcache
	pp.goidcache++
	newg.trace.reset()
	if trace.ok() {
		trace.GoCreate(newg, newg.startpc)
		traceRelease(trace)
	}

	// Set up race context.
	if raceenabled {
		newg.racectx = racegostart(callerpc)
		newg.raceignore = 0
		if newg.labels != nil {
			// See note in proflabel.go on labelSync's role in synchronizing
			// with the reads in the signal handler.
			racereleasemergeg(newg, unsafe.Pointer(&labelSync))
		}
	}
	releasem(mp)

	return newg
}
malg 创建新goroutine

主要就是分配了goroutine栈空间

// Allocate a new g, with a stack big enough for stacksize bytes.
func malg(stacksize int32) *g {
	newg := new(g)
	if stacksize >= 0 {
		stacksize = round2(stackSystem + stacksize)
		systemstack(func() {
			newg.stack = stackalloc(uint32(stacksize))
		})
		newg.stackguard0 = newg.stack.lo + stackGuard
		newg.stackguard1 = ^uintptr(0)
		// Clear the bottom word of the stack. We record g
		// there on gsignal stack during VDSO on ARM and ARM64.
		*(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
	}
	return newg
}
runqput g置P中

先尝试放高优先的runnext槽中，然后放P本地队列，实在不行就放全局队列

// runqput tries to put g on the local runnable queue.
// If next is false, runqput adds g to the tail of the runnable queue.
// If next is true, runqput puts g in the pp.runnext slot.
// If the run queue is full, runnext puts g on the global queue.
// Executed only by the owner P.
func runqput(pp *p, gp *g, next bool) {
	if randomizeScheduler && next && randn(2) == 0 {
		next = false
	}

  // 如果next为真，则尝试将gp发到pp.runnext中，如果有正在操作的，再进行尝试
	if next {
	retryNext:
		oldnext := pp.runnext
		if !pp.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
			goto retryNext
		}
		if oldnext == 0 {
			return
		}
		// Kick the old runnext out to the regular run queue.
    // 如果已经有goroutine，则踢出并放入常规运行队列
		gp = oldnext.ptr()
	}

  // 加入常规运行队列
retry:
  // 加载运行队列的头指针和尾指针
	h := atomic.LoadAcq(&pp.runqhead) // load-acquire, synchronize with consumers
	t := pp.runqtail
  
  // 如果队列未满，则将gp直接放入队列中
	if t-h < uint32(len(pp.runq)) {
		pp.runq[t%uint32(len(pp.runq))].set(gp)
		atomic.StoreRel(&pp.runqtail, t+1) // store-release, makes the item available for consumption
		return
	}
  
  // 如果队列已满，则尝试慢策略
	if runqputslow(pp, gp, h, t) {
		return
	}
	// the queue is not full, now the put above must succeed
	goto retry
}

runqputslow将一次性将本地队列中的多个g放入到全局队列中

// Put g and a batch of work from local runnable queue on global queue.
// Executed only by the owner P.
func runqputslow(pp *p, gp *g, h, t uint32) bool {
	var batch [len(pp.runq)/2 + 1]*g

	// First, grab a batch from local queue.
  // 先从本地队列中抓取一批g
	n := t - h
	n = n / 2
	if n != uint32(len(pp.runq)/2) {
		throw("runqputslow: queue is not full")
	}
	for i := uint32(0); i < n; i++ {
		batch[i] = pp.runq[(h+i)%uint32(len(pp.runq))].ptr()
	}
  // 如果cas失败，说明已经有其它工作线程从_p_的本地运行队列偷走了一些goroutine，所以直接返回
	if !atomic.CasRel(&pp.runqhead, h, h+n) { // cas-release, commits consume
		return false
	}
	batch[n] = gp

	if randomizeScheduler {
		for i := uint32(1); i <= n; i++ {
			j := cheaprandn(i + 1)
			batch[i], batch[j] = batch[j], batch[i]
		}
	}

  // 将需要放入全局运行队列的g连起来，减少后面对全局链表的锁住时间，从而降低锁冲突
	// Link the goroutines.
	for i := uint32(0); i < n; i++ {
		batch[i].schedlink.set(batch[i+1])
	}
	var q gQueue
	q.head.set(batch[0])
	q.tail.set(batch[n])

	// Now put the batch on global queue.
  // 将链表放入全局队列中
	lock(&sched.lock)
	globrunqputbatch(&q, int32(n+1))
	unlock(&sched.lock)
	return true
}

Grunnable -> Gruning

将指定的goroutine绑定到当前M上，其状态设置为运行，然后运行实际代码

func execute(gp *g, inheritTime bool) {
  // 获取当前正在运行的M
	mp := getg().m

  // 如果goroutine是活跃的，那么尝试记录当前goroutine的堆栈信息
	if goroutineProfile.active {
		tryRecordGoroutineProfile(gp, osyield)
	}

  // goroutine与M相互绑定，并更新goroutine为运行态
	mp.curg = gp
	gp.m = mp
	casgstatus(gp, _Grunnable, _Grunning)
  
  // 初始化goroutine其他信息
	gp.waitsince = 0
	gp.preempt = false
	gp.stackguard0 = gp.stack.lo + stackGuard
	if !inheritTime {
		mp.p.ptr().schedtick++
	}

	// Check whether the profiler needs to be turned on or off.
	hz := sched.profilehz
	if mp.profilehz != hz {
		setThreadCPUProfiler(hz)
	}

	trace := traceAcquire()
	if trace.ok() {
		// GoSysExit has to happen when we have a P, but before GoStart.
		// So we emit it here.
		if !goexperiment.ExecTracer2 && gp.syscallsp != 0 {
			trace.GoSysExit(true)
		}
		trace.GoStart()
		traceRelease(trace)
	}

  // 切换到goroutine调度上下文，实际执行goroutine代码
  // 就是从g0切换到g栈空间，并执行g的用户代码
	gogo(&gp.sched)
}

Gruning -> Gdead

对普通M（不是M0）而言，执行完任务之后，会进行到goexit，并等待重新调度

// Finishes execution of the current goroutine.
func goexit1() {
	if raceenabled {
		racegoend()
	}
	trace := traceAcquire()
	if trace.ok() {
		trace.GoEnd()
		traceRelease(trace)
	}
	mcall(goexit0)
}

// goexit continuation on g0.
func goexit0(gp *g) {
  // 销毁
	gdestroy(gp)
  // 调度：查找一个可运行的goroutine并执行
	schedule()
}
gdestroy 销毁goroutine

销毁其实就是更新状态为Gdead，清除goroutine数据，重新放回P空闲池中

func gdestroy(gp *g) {
  // 获取当前M与P
	mp := getg().m
	pp := mp.p.ptr()

  // 更新goroutine状态为Gdead
	casgstatus(gp, _Grunning, _Gdead)
  
  // 更新GC控制器。减少可扫描的堆栈大小
	gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))
  // 如果是系统goroutine，减少计数
	if isSystemGoroutine(gp, false) {
		sched.ngsys.Add(-1)
	}
  
  // 清除goroutine状态
	gp.m = nil
	locked := gp.lockedm != 0
	gp.lockedm = 0
	mp.lockedg = 0
	gp.preemptStop = false
	gp.paniconfault = false
	gp._defer = nil // should be true already but just in case.
	gp._panic = nil // non-nil for Goexit during panic. points at stack-allocated data.
	gp.writebuf = nil
	gp.waitreason = waitReasonZero
	gp.param = nil
	gp.labels = nil
	gp.timer = nil

	if gcBlackenEnabled != 0 && gp.gcAssistBytes > 0 {
		// Flush assist credit to the global pool. This gives
		// better information to pacing if the application is
		// rapidly creating an exiting goroutines.
		assistWorkPerByte := gcController.assistWorkPerByte.Load()
		scanCredit := int64(assistWorkPerByte * float64(gp.gcAssistBytes))
		gcController.bgScanCredit.Add(scanCredit)
		gp.gcAssistBytes = 0
	}

  // 释放当前M的goroutine
	dropg()

	if GOARCH == "wasm" { // no threads yet on wasm
		gfput(pp, gp)
		return
	}

	if mp.lockedInt != 0 {
		print("invalid m->lockedInt = ", mp.lockedInt, "\n")
		throw("internal lockOSThread error")
	}
  
  // 将 goroutine 放回空闲池
	gfput(pp, gp)
	if locked {
		// The goroutine may have locked this thread because
		// it put it in an unusual kernel state. Kill it
		// rather than returning it to the thread pool.

		// Return to mstart, which will release the P and exit
		// the thread.
		if GOOS != "plan9" { // See golang.org/issue/22227.
			gogo(&mp.g0.sched)
		} else {
			// Clear lockedExt on plan9 since we may end up re-using
			// this thread.
			mp.lockedExt = 0
		}
	}
}

Grunning -> Gwaiting

park_m主要负责将当前的 goroutine 暂停，切换其状态，并在必要时重新调度执行

// park continuation on g0.
func park_m(gp *g) {
	mp := getg().m

	trace := traceAcquire()

	// N.B. Not using casGToWaiting here because the waitreason is
	// set by park_m's caller.
  // 更改goroutine状态从Grunning到Gwaiting
	casgstatus(gp, _Grunning, _Gwaiting)
	if trace.ok() {
		trace.GoPark(mp.waitTraceBlockReason, mp.waitTraceSkip)
		traceRelease(trace)
	}

  // 将当前goroutine与M分离
	dropg()

  // 确保在某些条件下，安全地将 Goroutine 从等待状态移出，处理失败的解锁操作，并在必要时重新调度该 Goroutine
   // 调用解锁函数
	if fn := mp.waitunlockf; fn != nil {
		ok := fn(gp, mp.waitlock)
		mp.waitunlockf = nil
		mp.waitlock = nil
		if !ok {
			trace := traceAcquire()
			casgstatus(gp, _Gwaiting, _Grunnable)
			if trace.ok() {
				trace.GoUnpark(gp, 2)
				traceRelease(trace)
			}
			execute(gp, true) // Schedule it back, never returns.
		}
	}
  
  // 调度，切换到其他 goroutine 执行
	schedule()
}

Gwaiting -> Grunable

ready将指定的 goroutine 标记为可运行状态，并将其放入运行队列中

// Mark gp ready to run.
func ready(gp *g, traceskip int, next bool) {
  // 读取 gp 的当前状态
	status := readgstatus(gp)

  // 标记为可运行
	// Mark runnable.
	mp := acquirem() // disable preemption because it can be holding p in a local var
	if status&^_Gscan != _Gwaiting {
		dumpgstatus(gp)
		throw("bad g->status in ready")
	}

	// status is Gwaiting or Gscanwaiting, make Grunnable and put on runq
	trace := traceAcquire()
	casgstatus(gp, _Gwaiting, _Grunnable)
	if trace.ok() {
		trace.GoUnpark(gp, traceskip)
		traceRelease(trace)
	}
  
  // 将 gp 放入当前 P 的运行队列中。如果 next 为 true，表示将 gp 放在队列的前面，否则放在队列的后面
	runqput(mp.p.ptr(), gp, next)
  // 确保有一个 P 可以运行 gp
	wakep()
  // 重新启用当前M的抢占
	releasem(mp)
}

Grunning -> Grunnable

goschedImpl 函数用于将当前 goroutine 交出 CPU，使其重新排队等待调度执行。它的实现涉及状态检查、状态变更、跟踪信息处理、全局运行队列操作和重新调度

goschedImpl 函数执行的主要步骤包括：

  1. 获取并验证 gp 的当前状态。
  2. 将 gp 的状态修改为 _Grunnable，表示它现在是可运行状态。
  3. 解绑当前 M 和 gp。
  4. 获取调度器锁并将 gp 放入全局运行队列。
  5. 如果主 goroutine 已经启动，则唤醒一个 P 以确保运行队列中的 goroutine 被处理。
  6. 重新进入调度循环，选择下一个可运行的 goroutine 开始执行。
func goschedImpl(gp *g, preempted bool) {
	trace := traceAcquire()
	status := readgstatus(gp)
	if status&^_Gscan != _Grunning {
		dumpgstatus(gp)
		throw("bad g status")
	}
	casgstatus(gp, _Grunning, _Grunnable)
	if trace.ok() {
		if preempted {
			trace.GoPreempt()
		} else {
			trace.GoSched()
		}
		traceRelease(trace)
	}

	dropg()
	lock(&sched.lock)
	globrunqput(gp)
	unlock(&sched.lock)

	if mainStarted {
		wakep()
	}

	schedule()
}

大致总结下

go池是所有拥有goroutine的地方，包括P的runnext、P本地队列和全局队列

  • Gidle -> Grunnable: 初始化g，放入go池
  • Grunnable -> Grunning: 从go池取出，绑定M，执行实际代码
  • Grunning
    • -> Gdead: 解绑M，重置g，重新放入go池
    • -> Gwaiting: 解绑M，等待被唤醒
    • -> Grunnable: 解绑M，放入go全局队列
  • Gwaiting -> Grunable: 被唤醒后放入go池
  1. https://github.com/LeoYang90/Golang-Internal-Notes/blob/master/Go%20%E5%8D%8F%E7%A8%8B%E8%B0%83%E5%BA%A6%E2%80%94%E2%80%94%E5%9F%BA%E6%9C%AC%E5%8E%9F%E7%90%86%E4%B8%8E%E5%88%9D%E5%A7%8B%E5%8C%96.md
动态一时爽，重构火葬场
关注
  • 19
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang goroutine实现_Golang 的 goroutine 是如何实现的？
weixin_39620037的博客
12-24 136
goroutine 实现:我们去看调度的一个进化, 从进程到线程再到协程, 其实是一个不断共享, 不断减少切换成本的过程. go 实现的协程为有栈协程, go 协程的用法和线程的用法基本类似. 很多人会疑问, 协程到底是个什么东西? 用户态的调度感觉很陌生, 很抽象, 到底是个什么东西?我觉得要理解调度, 要理解两个概念: 运行和阻塞. 特别是在协程中, 这两个概念不容易被正确理解. 我们理解概念...
golang goroutine 限不限制并发量
强颜欢笑
07-26 897
问题 func main() { userCount := math.MaxInt64 for i := 0; i < userCount; i++ { go func(i int) { // 做一些各种各样的业务逻辑处理 fmt.Printf("go func: %d\n", i) ...
go笔记之——goroutine
qq_52563729的博客
08-01 528
1
Go 群友提问：Goroutine 数量控制在多少合适，会影响 GC 和调度？
EDDYCJY的博客
03-12 1809
大家好，我是煎鱼。前几天在读者交流群里看到一位小伙伴，发出了一个致命提问，那就是：“单机的 goroutine 数量控制在多少比较合适？”。也许你和群内小伙伴第一反应一样，会答复 “控制多...
Goroutine 数量控制在多少合适，会影响 GC 和调度？
Shanks
03-12 1442
以下内容转载自https://mp.weixin.qq.com/s/uWP2X6iFu7BtwjIv5H55vw 大家好，我是煎鱼。 前几天在读者交流群里看到一位小伙伴，发出了一个致命提问，那就是：“单机的 goroutine 数量控制在多少比较合适？”。 也许你和群内小伙伴第一反应一样，会答复 “控制多少，我觉得没有定论”。 紧接着延伸出了更进一步的疑惑：“goroutine 太多了会影响 gc 和调度吧，主要是怎么预算这个数是合理的呢？” 这是本文要进行探讨的主体，因此本文的结构会是先探索基.
千军万马跑协程goroutine
rs勿忘初心的博客
10-12 241
参考：https://cloud.tencent.com/developer/article/1375753 协程和通道是 Go 语言作为并发编程语言最为重要的特色之一，初学者可以完全将协程理解为线程，但是用起来比线程更加简单，占用的资源也更少。通常在一个进程里启动上万个线程就已经不堪重负，但是 Go 语言允许你启动百万协程也可以轻松应付。如果把协程比喻成小岛，那通道就是岛屿之间的...
GoLang协程原理解读，收藏作为面经再合适不过了
程序猿的世界
12-28 1519
线程实现模型 在操作系统提供的内核线程之上，Go 搭建了一个特有的用户级线程模型。传统的函数调用是将函数指针存储在内存的栈空间上，但是栈空间只允许操作系统进行操作，我们能拿到的只限于堆内存，所以 Go 开发者在堆上申请一块内存，将寄存器 %rsp 以及寄存器 %rbp 指过去，从而将这块内存伪装成用户栈，从而巧妙地实现了并行运行用户级线程 goroutine。要聊 Go 的线程实现模型，必须要知道以下3个核心元素： M：machine 缩写，一个 M 代表一个内核线程。 P：proces...
goroutine并发MySQL_来，控制一下 Goroutine 的并发数量
weixin_30131443的博客
02-23 174
问题func main() {userCount := math.MaxInt64for i := 0; i < userCount; i++ {go func(i int) {// 做一些各种各样的业务逻辑处理fmt.Printf("go func: %d\n", i)time.Sleep(time.Second)}(i)}}在这里，假设 userCount 是一个外部传入的参数(不可预测...
几个提升Go语言开发效率的小技巧
EDDYCJY的博客
08-02 310
前言哈喽，大家好，我是asong。每门语言都有自己的语法糖，像java的语法糖就有方法变长参数、拆箱与装箱、枚举、for-each等等，Go语言也不例外，其也有自己的语法糖，掌握这些语法糖可以助我们提高开发的效率，所以本文就来介绍一些Go语言的语法糖，总结的可能不能全，欢迎评论区补充。可变长参数Go语言允许一个函数把任意数量的值作为参数，Go语言内置了...操作符，在函数...
docker安装与container基本使用
andy dennis的博客
07-29 415
Homebrew 的 Cask 已经支持 Docker for Mac, mac用户狂喜其他入门用法可参考或网上自行搜索博客学习。本文主要记录我运行go-zero-mall用到的一些注意点。当然，gonivinck项目书写的dockerfile格式也可以为我们平时日常开发做参考。
Go语言加Vue3零基础入门全栈班10 Go语言+gRPC用户微服务项目实战 2024年07月31日 课程笔记
Python私教
07-31 536
如果您没有Golang的基础，应该学习如下前置课程。Golang零基础入门Golang面向对象编程Go Web 基础Go语言开发REST API接口_20240728Go语言操作MySQL开发用户管理系统API教程_20240729Redis零基础快速入门_20231227Go+Redis开发用户管理系统API实战_20240730MongoDB快速入门_20240411Go语言+MongoDB用户管理系统实战_20240730。
golang编码最佳实践(持续更新中)
sunny8zhou的专栏
08-01 332
最近在学习go语言，以此记录日常编码中的最佳实践，欢迎大家一起讨论。
Golang | Leetcode Golang题解之第310题最小高度树
weixin_66442839的博客
08-01 160
Golang | Leetcode Golang题解之第310题最小高度树
排序算法：插入排序，golang实现
幸享龙枫的博客
07-31 775
在实际场景中，选择合适的排序算法对于提高程序的效率和性能至关重要，本节课主要讲解"插入排序"的适用场景及代码实现。
RocketMQ5.0 生产者
m0_61253599的博客
08-01 176
生产者消息类型：
【Golang 面试 - 进阶题】每日 3 题（十一）
最新发布
Newin2020的博客
08-01 686
📚专栏简介：在这个专栏中，我将会分享 Golang 面试中常见的面试题给大家~
Golang 高性能 Websocket 库 gws 使用与设计（一）
qq_41468830的博客
07-27 745
GitHub 🌟 1.2k，高性能的 websocket 库，代码双语注释，适合有开发经验的同学进阶学习。
Golang 知识结构图
飞越蓝天的专栏
07-28 178
        总结Go的入门知识结构，如下图所示：
go如何进行调度的，GMP中状态流转
06-14
Go 语言通过 GMP（Goroutine, M, P） 模型来进行调度，其中 Goroutine 是 Go 语言中的轻量级线程，M（Machine）是 Go 语言运行时的线程，P（Processor）是逻辑处理器，它用于管理 Goroutine 的运行和调度。 Goroutine 会被调度到 M 上执行，M 可以同时运行多个 Goroutine，每个 M 都有一个 P 和一个 G 的队列，P 用于管理和调度 Goroutine，G 队列存储等待运行的 Goroutine，队列中的 Goroutine 按照 FIFO（先进先出）的原则进行调度。 当一个 Goroutine 需要被执行时，P 会从 G 队列中取出一个 Goroutine，将其与一个 M 绑定，然后再将 M 放入运行队列中等待 CPU 执行。当一个 Goroutine 阻塞时，P 会将其从 M 上摘下，然后将其放入等待队列中等待下一次调度。 在 GMP 模型中，M 和 P 之间有三种状态（Running、Idle、Blocked），M 和 G 之间也有三种状态（Running、Runnable、Waiting）： - M 的 Running 状态表示该 M 正在执行 Goroutine； - M 的 Idle 状态表示该 M 没有 Goroutine 可以执行； - M 的 Blocked 状态表示该 M 正在等待某些事件的发生，比如等待 Goroutine 阻塞或等待系统资源； - G 的 Running 状态表示该 Goroutine 正在被某一个 M 执行； - G 的 Runnable 状态表示该 Goroutine 准备好被执行，但是还没有被 M 取走； - G 的 Waiting 状态表示该 Goroutine 正在等待某些事件的发生，比如等待 I/O 完成或等待定时器超时。 总之，GMP 模型是 Go 语言调度的核心，它的状态流转是 Go 语言进行调度的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值