Go中的父子上下文取消订单

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{}{}
}