关于思否技术征文:动图图解怎么让goroutine跑一半就退出

3次阅读

共计 4854 个字符，预计需要花费 13 分钟才能阅读完成。

本文参加了思否技术征文，欢送正在浏览的你也退出。

光看题目，大家可能不太了解我说的是啥。

咱们平时创立一个协程，跑一段逻辑，代码大略长这样。

package main

import (
    "fmt"
    "time"
)
func Foo() {fmt.Println("打印 1")
    defer fmt.Println("打印 2")
    fmt.Println("打印 3")
}

func main() {go  Foo()
    fmt.Println("打印 4")
    time.Sleep(1000*time.Second)
}

// 这段代码，失常运行会有上面的后果
打印 4
打印 1
打印 3
打印 2

留神这下面 ”打印 2 “ 是在 defer 中的，所以会在函数完结前打印。因而后置于 ”打印 3 “。

那么明天的问题是，如何让 Foo() 函数 跑一半就完结 ，比如说跑到 打印 2 ，就退出协程。输入如下后果

打印 4
打印 1
打印 2

也不卖关子了，我这边间接说答案。

在 ” 打印 2 ″ 前面插入一个 runtime.Goexit()，协程就会间接完结。并且完结前还能执行到 defer 里的 打印 2 。

package main

import (
    "fmt"
    "runtime"
    "time"
)
func Foo() {fmt.Println("打印 1")
    defer fmt.Println("打印 2")
    runtime.Goexit() // 退出这行
    fmt.Println("打印 3")
}

func main() {go  Foo()
    fmt.Println("打印 4")
    time.Sleep(1000*time.Second)
}


// 输入后果
打印 4
打印 1
打印 2

能够看到 打印 3 这一行没呈现了，协程的确提前结束了。

其实面试题到这里就讲完了，这一波自问自答可还行？

但这不是明天的重点，咱们须要搞搞分明外部的逻辑。

看一下外部实现。

func Goexit() {
    // 以下函数省略一些逻辑...
    gp := getg() 
    for {
    // 获取 defer 并执行
        d := gp._defer
        reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
    }
    goexit1()}

func goexit1() {mcall(goexit0)
}

从代码上看，runtime.Goexit()会先执行一下 defer 里的办法，这里就解释了结尾的代码里为什么 在 defer 里的打印 2 能失常输入。

而后代码再执行 goexit1。实质就是对goexit0 的简略封装。

咱们能够把代码持续跟上来，看看 goexit0 做了什么。

// goexit continuation on g0.
func goexit0(gp *g) {
  // 获取以后的 goroutine
    _g_ := getg()
    // 将以后 goroutine 的状态置为 _Gdead
    casgstatus(gp, _Grunning, _Gdead)
  // 全局协程数减一
    if isSystemGoroutine(gp, false) {atomic.Xadd(&sched.ngsys, -1)
    }
  
  // 省略各种清空逻辑...

  // 把 g 从 m 上摘下来。dropg()


    // 把这个 g 放回到 p 的本地协程队列里，放不下放全局协程队列。gfput(_g_.m.p.ptr(), gp)

  // 从新调度，拿下一个可运行的协程进去跑
    schedule()}

这段代码，信息密度比拟大。

很多名词可能让人一脸懵。

简略形容下，Go 语言里有个 GMP 模型 的说法，M是内核线程，G也就是咱们平时用的协程 goroutine，P 会在 G 和 M 之间 做工具人，负责调度 G 到M上运行。

既然是调度，也就是说不是每个G 都能始终处于运行状态，等 G 不能运行时，就把它存起来，再调度下一个能运行的 G 过去运行。

临时不能运行的 G，P 上会有个 本地队列 去寄存这些这些 G，P 的本地队列存不下的话，还有个全局队列，干的事件也相似。

理解这个背景后，再回到 goexit0 办法看看，做的事件就是将以后的协程 G 置为 _Gdead 状态，而后把它从 M 上摘下来，尝试放回到 P 的本地队列中。而后从新调度一波，获取另一个能跑的 G，拿进去跑。

所以简略总结一下，只有执行 goexit 这个函数，以后协程就会退出，同时还能调度下一个可执行的协程进去跑。

看到这里，大家应该就能了解，结尾的代码里，为什么 runtime.Goexit() 能让协程只执行一半就完结了。

看是看懂了，然而会忍不住纳闷。面试这么问问，那只能阐明你遇到了一个喜爱尴尬年轻人的面试官 ，但正经人谁会没事跑一半协程就完结呢？所以goexit 的实在用处 是啥？

有个 小细节，不晓得大家平时 debug 的时候有没有关注过。

为了阐明问题，这里先给出一段代码。

package main

import (
    "fmt"
    "time"
)
func Foo() {fmt.Println("打印 1")
}

func main() {go  Foo()
    fmt.Println("打印 3")
    time.Sleep(1000*time.Second)
}

这是一段非常简单的代码，输入什么齐全不重要。通过 go 关键字启动了一个 goroutine 执行 Foo()，外面打印一下就完结，主协程sleep 很长时间，只为死等。

这里咱们新启动的协程里，在 Foo() 函数内轻易打个断点。而后 debug 一下。

会发现，这个协程的堆栈底部是从 runtime.goexit() 里开始启动的。

如果大家平时有留神察看，会发现，其实所有的堆栈底部，都是从这个函数开始的。咱们持续跟跟代码。

从下面的 debug 堆栈里点进去会发现，这是个汇编函数，能够看出调用的是 runtime 包内的 goexit1() 函数。

// The top-most function running on a goroutine
// returns to goexit+PCQuantum.
TEXT runtime·goexit(SB),NOSPLIT,$0-0
    BYTE    $0x90    // NOP
    CALL    runtime·goexit1(SB)    // does not return
    // traceback from goexit1 must hit code range of goexit
    BYTE    $0x90    // NOP

于是跟到了 pruntime/proc.go 里的代码中。

// 省略局部代码
func goexit1() {mcall(goexit0)
}

是不是很相熟，这不就是咱们结尾讲 runtime.Goexit() 里外部执行的 goexit0 吗。

咱们首先须要晓得的是，函数栈的执行过程，是先进后出。

假如咱们有以下代码

func main() {B()
}

func B() {A()
}

func A() {}

下面的代码是 main 运行 B 函数，B 函数再运行 A 函数，代码执行时就跟上面的动图那样。

这个是先进后出的过程，也就是咱们常说的函数栈，执行完 子函数 A()后，就会回到 父函数 B()中，执行完 B() 后，最初就会回到 main()。这里的栈底是main()，如果在栈底插入的是 goexit 的话，那么当程序执行完结的时候就都能跑到 goexit 里去。

联合后面讲过的内容，咱们就能晓得，此时栈底的 goexit，会在协程内的业务代码跑完后被执行到，从而实现协程退出，并调度下一个 可执行的 G 来运行。

那么问题又来了，栈底插入 goexit 这件事是谁做的，什么时候做的？

间接说答案，这个在 runtime/proc.go 里有个 newproc1 办法，只有是 创立协程 都会用到这个办法。外面有个中央是这么写的。

func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) {
    // 获取以后 g
  _g_ := getg()
    // 获取以后 g 所在的 p
    _p_ := _g_.m.p.ptr()
  // 创立一个新 goroutine
    newg := gfget(_p_)

    // 底部插入 goexit
    newg.sched.pc = funcPC(goexit) + sys.PCQuantum 
    newg.sched.g = guintptr(unsafe.Pointer(newg))
    // 把新创建的 g 放到 p 中
    runqput(_p_, newg, true)

    // ...
}

次要的逻辑是获取以后协程 G 所在的调度器 P，而后创立一个新 G，并在栈底插入一个 goexit。

所以咱们每次 debug 的时候，就都能看到函数栈底部有个 goexit 函数。

对于 main 函数栈底是不是也有个goexit，咱们对上面代码断点看下。间接得出后果。

main 函数栈底也是goexit()。

从 asm_amd64.s能够看到 Go 程序启动的流程，这里提到的 runtime·mainPC 其实就是 runtime.main.

    // create a new goroutine to start program
    MOVQ    $runtime·mainPC(SB), AX        // 也就是 runtime.main
    PUSHQ    AX
    PUSHQ    $0            // arg size
    CALL    runtime·newproc(SB)

通过 runtime·newproc 创立 runtime.main 协程，而后在 runtime.main 里会启动 main.main 函数，这个就是咱们平时写的那个 main 函数了。

// runtime/proc.go
func main() {
    // 省略大量代码
    fn := main_main // 其实就是咱们的 main 函数入口
    fn()}

//go:linkname main_main main.main
func main_main()

论断是，其实 main 函数也是由 newproc 创立的，只有通过 newproc 创立的 goroutine，栈底就会有一个 goexit。

最初再回到结尾的问题，实现一下首尾呼应。

结尾的面试题，除了runtime.Goexit()，是不是还能够改为用os.Exit()？

同样都是带有 ” 退出 ” 的含意，两者退出的对象不同。os.Exit() 指的是整个过程退出；而 runtime.Goexit() 指的是协程退出。

可想而知，改用os.Exit() 这种状况下，defer 里的内容就不会被执行到了。

package main

import (
    "fmt"
    "os"
    "time"
)
func Foo() {fmt.Println("打印 1")
    defer fmt.Println("打印 2")
    os.Exit(0)
    fmt.Println("打印 3")
}

func main() {go  Foo()
    fmt.Println("打印 4")
    time.Sleep(1000*time.Second)
}

// 输入后果
打印 4
打印 1

通过 runtime.Goexit()能够做到提前结束协程，且完结前还能执行到 defer 的内容
runtime.Goexit()其实是对 goexit0 的封装，只有执行 goexit0 这个函数，以后协程就会退出，同时还能调度下一个可执行的协程进去跑。
通过 newproc 能够创立出新的goroutine，它会在函数栈底部插入一个 goexit。
os.Exit() 指的是整个过程退出；而 runtime.Goexit() 指的是协程退出。两者含意有区别。

无用的常识又减少了。

个别状况下，业务开发中，谁会没事执行这个函数呢？

然而开发中不关怀，不代表面试官不关怀！

下次面试官问你，如果想在 goroutine 执行一半就退出协程，该怎么办？你晓得该怎么答复了吧？

好了，兄弟们，有没有发现这篇文章写的又水又短，真的是因为我变懒了吗？

不！

当然不！

我是为了兄弟们的身体健康思考，放弃蹲姿太久对身材不好，懂？

如果文章对你有帮忙，欢送 …..

算了。

一起在常识的陆地里呛水吧

我是小白，咱们下期见！

饶大的《哪来里的 goexit？》- https://qcrao.com/2021/06/07/…

正文完

思否技术征文

发表至：思否技术征文

2022-11-23

0

关于思否技术征文:Go-函数包的使用

关于思否技术征文:Go微服务开发gRPC总共分三步

关于思否技术征文:几行代码带你彻底搞懂Java内部类

关于思否技术征文:Javaweb-自定义-Servlet-实现按照访问路径转发

关于深度学习:寒冬之下年销售增速不降反增这家国企做对了什么

关于思否技术征文:动图图解怎么让goroutine跑一半就退出

runtime.Goexit()是什么？

goexit 的用处

goexit 是什么？

为什么每个堆栈底部都是这个办法？

main 函数也是个协程，栈底也是 goexit？

os.Exit()和 runtime.Goexit()有什么区别

总结

最初

参考资料

站内搜索