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