当前位置： > > > > Go 中的父子上下文取消顺序

Go 中的父子上下文取消顺序

来源：stackoverflow
2024-04-30 14:42:36
0浏览
收藏

知识点掌握了，还需要不断练习才能熟练运用。下面米云给大家带来一个Golang开发实战，手把手教大家学习《Go 中的父子上下文取消顺序》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

问题内容

我想知道golang中上下文取消时的返回顺序是否有任何保证。

我想创建一个具有取消功能的上下文，一旦所有侦听器都完成了处理捕获并对此上下文中的“<-ctx.done()”做出反应，我想安全地调用 os.exit。

下面是一个具体的例子来解释我想要的想法。我想捕获一个信号，触发所有取消，然后调用 os.exit()。

我创建一个上下文并监听信号：

ctx, cancel := context.withcancel(context.background())
go func() {
    c := make(chan os.signal)
    signal.notify(c, os.interrupt)
    defer signal.stop(c)

    select {
    case <-c:
        cancel()
    }
}()

在其他地方，我多次“注册”此请求：

res := newres()
go func() {
    <-ctx.done():
    res.close()
}()

但是我想在所有侦听器完成时调用 os.exit。

为此，我计划创建父上下文或子上下文，如下所示：

parent, pCancel := context.WithCancel(context.Background())
child, _ := context.WithCancel(parent)
go func() {
    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt)
    defer signal.Stop(c)

    select {
    case <-c:
        pCancel()
    case <-child.Done():
        os.Exit(0)
    }
}()

不幸的是，我没有找到描述上下文取消顺序的文档，所以我暂时无法提出正确的解决方案。

解决方案

退出之前您必须等待所有例程。调用 pcancel() 并不意味着一切都会停止。我建议在例程中完成所有作业，但在主线程上等待 os.interrupt 信号。

检查下面的示例

package main

import (
    "context"
    "fmt"
    "os"
    "os/signal"
    "sync"
    "time"
)

func main() {
    parent, pcancel := context.withcancel(context.background())
    child, _ := context.withcancel(parent)
    wg := &sync.waitgroup{}

    for i := 0; i < 10; i++ {
        go work(wg, child)
    }

    c := make(chan os.signal)
    signal.notify(c, os.interrupt)
    defer signal.stop(c)

    select {
    case <-c:
        pcancel()
        fmt.println("waiting everyone to finish...")
        wg.wait()
        fmt.println("exiting")
        os.exit(0)
    }
}

func work(wg *sync.waitgroup, ctx context.context) {
    done := false
    wg.add(1)
    for !done {
        fmt.println("doing something...")
        time.sleep(time.second)
        select {
        case <-ctx.done():
            fmt.println("done")
            done = true
        default:

        }
    }
    wg.done()
}

尽管如此，还是建议使用“通过通信共享内存”原则。 这是不使用 waitgroup 的另一个示例。

package main

import (
    "context"
    "fmt"
    "os"
    "os/signal"
    "time"
)

func main() {
    parent, pCancel := context.WithCancel(context.Background())
    child, _ := context.WithCancel(parent)
    done := make(chan struct{})
    jobsCount := 10

    for i := 0; i < jobsCount; i++ {
        go work(child, done)
    }

    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt)
    defer signal.Stop(c)

    select {
    case <-c:
        pCancel()
        fmt.Println("Waiting everyone to finish...")
        for i := 0; i < jobsCount; i++ {
            <-done
        }
        fmt.Println("Exiting")
        os.Exit(0)
    }
}

func work(ctx context.Context, doneChan chan struct{}) {
    done := false
    for !done {
        fmt.Println("Doing something...")
        time.Sleep(time.Second)
        select {
        case <-ctx.Done():
            fmt.Println("Done")
            done = true
        default:

        }
    }
    doneChan <- struct{}{}
}

今天关于《Go 中的父子上下文取消顺序》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注米云公众号！