如何以惯用的方式优雅地关闭链式 goroutine

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《如何以惯用的方式优雅地关闭链式 goroutine》，涉及到，有需要的可以收藏一下

创建多个 goroutine，这些 goroutine 将具有嵌套 goroutine，同时以多级方式进行处理（想象一棵 goroutine 树，每个级别可以有许多叶子）。

按顺序优雅地关闭这些 goroutine 并等待它们回来的惯用方法是什么？顺序是从下到上（最深的孩子在前），并且假设我不知道我将提前启动多少个 goroutine（动态）。

下面的示例只是以非有序方式优雅地关闭它们。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)

    //level1
    go func() {
        fmt.Println("level1 started")
        //level2
        go func() {
            fmt.Println("level2 started")

            //level3
            go func() {
                fmt.Println("level3 started")
                select {
                case <-ctx.Done():
                    fmt.Println("Done called on level3")
                case <-time.After(5* time.Second):
                    fmt.Println("After called on level3")
                }

            }()
            select {
            case <-ctx.Done():
                fmt.Println("Done called on level2")
            case <-time.After(7* time.Second):
                fmt.Println("After called on level2")
            }

        }()
        select {
        case <-ctx.Done():
            fmt.Println("Done called on level1")
        case <-time.After(10* time.Second):
            fmt.Println("After called on level1")
        }


    }()
    time.Sleep(1*time.Second)
    cancel()
    time.Sleep(1 * time.Second)
}

解决方案

要等待一组 goroutine，sync.WaitGroup 是惯用的解决方案。当你启动一个新的 goroutine (WaitGroup.Add()) 时，你可以给它的计数器加 1，并且 goroutine 可以用 WaitGroup.Done() 发出信号表明它已经完成。父 goroutine 可以调用 WaitGroup.Wait() 来等待它的所有子 goroutine 完成。

您可以在每个级别上执行相同的操作。在启动子协程的每个级别上创建一个 waitgroup，并且仅当该协程的 wait() 返回时才返回。

以下是它在您的示例中的应用方式：

ctx := context.background()
ctx, cancel := context.withcancel(ctx)

//level1
wg1 := &sync.waitgroup{}
wg1.add(1)
go func() {
    defer wg1.done()
    fmt.println("level1 started")
    //level2
    wg2 := &sync.waitgroup{}
    wg2.add(1)
    go func() {
        defer wg2.done()
        fmt.println("level2 started")

        //level3
        wg3 := &sync.waitgroup{}
        wg3.add(1)
        go func() {
            defer wg3.done()
            fmt.println("level3 started")
            select {
            case <-ctx.done():
                fmt.println("done called on level3")
            case <-time.after(5 * time.second):
                fmt.println("after called on level3")
            }
            fmt.println("level 3 ended.")
        }()

        select {
        case <-ctx.done():
            fmt.println("done called on level2")
        case <-time.after(7 * time.second):
            fmt.println("after called on level2")
        }
        wg3.wait()
        fmt.println("level 2 ended.")
    }()

    select {
    case <-ctx.done():
        fmt.println("done called on level1")
    case <-time.after(10 * time.second):
        fmt.println("after called on level1")
    }
    wg2.wait()
    fmt.println("level 1 ended.")
}()

time.sleep(1 * time.second)
cancel()
wg1.wait()
fmt.println("main ended.")

此输出（在 Go Playground 上尝试）：

level1 started
level2 started
level3 started
done called on level1
done called on level3
level 3 ended.
done called on level2
level 2 ended.
level 1 ended.
parent ended.

输出中重要的内容：

Level 3 ended.
Level 2 ended.
Level 1 ended.
Main ended.

级别以降序级别结束（从下到上），以 “主要结束。” 结束。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。