如何在Go协程中从任意栈深度退出

package main

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

func foo() {
    fmt.Println("Entering foo()")
    // 在这里调用 runtime.Goexit() 将直接终止当前协程
    runtime.Goexit()
    // 这行代码将永远不会被执行
    fmt.Println("Exiting foo() - This will not be printed")
}

func bar() {
    fmt.Println("Entering bar()")
    foo()
    // 这行代码将永远不会被执行
    fmt.Println("Exiting bar() - This will not be printed")
}

func myGoroutine() {
    fmt.Println("Goroutine started.")
    // 注册一个 defer 函数，验证 Goexit() 会执行它
    defer fmt.Println("Goroutine defer function executed.")
    for i := 0; i < 5; i++ {
        fmt.Printf("Goroutine iteration %d\n", i)
        if i == 2 {
            bar() // 在第三次迭代时调用 bar()，进而调用 foo() 退出
        }
        time.Sleep(100 * time.Millisecond) // 模拟工作
    }
    fmt.Println("Goroutine finished normally - This will not be printed if Goexit() is called.")
}

func main() {
    fmt.Println("Main goroutine started.")
    go myGoroutine()

    // 主协程等待一段时间，以确保子协程有机会执行并退出
    time.Sleep(2 * time.Second)
    fmt.Println("Main goroutine finished.")
}

Main goroutine started.
Goroutine started.
Goroutine iteration 0
Goroutine iteration 1
Goroutine iteration 2
Entering bar()
Entering foo()
Goroutine defer function executed.
Main goroutine finished.

package main

import (
    "fmt"
    "time"
)

// 定义一个自定义错误类型，用于panic
type ExitGoroutineError struct{}

func fooWithPanic() {
    fmt.Println("Entering fooWithPanic()")
    // 在这里触发 panic
    panic(ExitGoroutineError{})
    // 这行代码将永远不会被执行
    fmt.Println("Exiting fooWithPanic() - This will not be printed")
}

func barWithPanic() {
    fmt.Println("Entering barWithPanic()")
    fooWithPanic()
    // 这行代码将永远不会被执行
    fmt.Println("Exiting barWithPanic() - This will not be printed")
}

func myGoroutineWithPanic() {
    fmt.Println("GoroutineWithPanic started.")
    // 在协程的入口处设置 defer 和 recover
    defer func() {
        if r := recover(); r != nil {
            // 检查 recover 的值是否是我们期望的退出信号
            if _, ok := r.(ExitGoroutineError); ok {
                fmt.Println("GoroutineWithPanic caught ExitGoroutineError and exited gracefully.")
            } else {
                // 如果是其他类型的 panic，重新抛出或处理
                fmt.Printf("GoroutineWithPanic caught unexpected panic: %v\n", r)
                // 或者重新 panic(r)
            }
        }
        fmt.Println("GoroutineWithPanic defer function executed.")
    }()

    for i := 0; i < 5; i++ {
        fmt.Printf("GoroutineWithPanic iteration %d\n", i)
        if i == 2 {
            barWithPanic() // 在第三次迭代时调用 barWithPanic()，进而调用 fooWithPanic() 触发 panic
        }
        time.Sleep(100 * time.Millisecond) // 模拟工作
    }
    fmt.Println("GoroutineWithPanic finished normally - This will not be printed if panic is called.")
}

func main() {
    fmt.Println("Main goroutine started.")
    go myGoroutineWithPanic()

    // 主协程等待一段时间，以确保子协程有机会执行并退出
    time.Sleep(2 * time.Second)
    fmt.Println("Main goroutine finished.")
}

Main goroutine started.
GoroutineWithPanic started.
GoroutineWithPanic iteration 0
GoroutineWithPanic iteration 1
GoroutineWithPanic iteration 2
Entering barWithPanic()
Entering fooWithPanic()
GoroutineWithPanic caught ExitGoroutineError and exited gracefully.
GoroutineWithPanic defer function executed.
Main goroutine finished.