Question

我想知道在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)
    }
}()

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

Answer 1

在退出之前，您必须等待所有例程。调用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中的父子上下文取消顺序

1 个答案: