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

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

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

package mainimport (    "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 mainimport (    "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这一行没呈现了，协程的确提前结束了。

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

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

runtime.Goexit()是什么？

看一下外部实现。

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的用处

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

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

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

package mainimport (    "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()里开始启动的。

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

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，咱们对上面代码断点看下。间接得出后果。

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.gofunc main() {    // 省略大量代码    fn := main_main // 其实就是咱们的main函数入口    fn() }//go:linkname main_main main.mainfunc main_main()

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

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

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

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

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

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

package mainimport (    "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/...