Goroutine看不到上下文取消？

Question

我同时有两个goroutines。

在某个时候，我希望我的程序优雅地退出，以便我使用cancel（） func通知我的goroutines，他们需要停止它们，但只有两者中的一个收到消息。

这是我的主要（简化）：

ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)

done := make(chan os.Signal, 1)
signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)

wg := &sync.WaitGroup{}
wg.Add(2)

go func() {
    err := eng.Watcher(ctx, wg)
    if err != nil {
        cancel()
    }
}()

go func() {
    err := eng.Suspender(ctx, wg)
    if err != nil {
        cancel()
    }
}()

<-done // wait for SIGINT / SIGTERM
log.Print("receive shutdown")
cancel()
wg.Wait()

log.Print("controller exited properly")

吊销Goroutine成功存在（这是代码）：

package main

import (
    "context"
    "sync"
    "time"

    log "github.com/sirupsen/logrus"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/util/retry"
)

func (eng *Engine) Suspender(ctx context.Context, wg *sync.WaitGroup) error {

    contextLogger := eng.logger.WithFields(log.Fields{
        "go-routine": "Suspender",
    })
    contextLogger.Info("starting Suspender goroutine")
    now := time.Now().In(eng.loc)

    for {
        select {
        case n := <-eng.Wl:
            //dostuff


        case <-ctx.Done():
            // The context is over, stop processing results
            contextLogger.Infof("goroutine Suspender canceled by context")
            return nil
        }
    }

}

这是未接收上下文取消的功能：

package main

import (
    "context"
    "sync"
    "time"

    log "github.com/sirupsen/logrus"
)

func (eng *Engine) Watcher(ctx context.Context, wg *sync.WaitGroup) error {
    contextLogger := eng.logger.WithFields(log.Fields{
        "go-routine":      "Watcher",
        "uptime-schedule": eng.upTimeSchedule,
    })
    contextLogger.Info("starting Watcher goroutine")

    ticker := time.NewTicker(time.Second * 30)
    for {
        select {
        case <-ctx.Done():
            contextLogger.Infof("goroutine watcher canceled by context")
            log.Printf("toto")
            return nil
        case <-ticker.C:
            
                //dostuff
            }
        }
    }
}

您能帮我吗？

谢谢 ：）

Answer 1

您是否使用Errgroup尝试过？它具有上下文取消的烤制：

ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)
defer cancel()

done := make(chan os.Signal, 1)
signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)

// "golang.org/x/sync/errgroup"
wg, ctx := errgroup.WithContext(ctx)

wg.Go(func() error {
    return eng.Watcher(ctx, wg)
})

wg.Go(func() error {
    return eng.Suspender(ctx, wg)
})

wg.Go(func() error {
    defer cancel()
    <-done
    return nil
})

err := wg.Wait()
if err != nil {
    log.Print(err)
}

log.Print("receive shutdown")
log.Print("controller exited properly")

Answer 2

从表面上看，代码看起来不错。我唯一能想到的是它忙于“ dostuff”。在调试器中逐步浏览与计时相关的代码可能很棘手

  case <-ticker.C:
     log.Println("doing stuff")
     //dostuff
     log.Println("done stuff")

：不是您描述的问题的原因。）

Answer 3

suspender和Watcher中的代码不会通过done（）方法调用 - 无限执行背后的原因。

老实说，忘记这么小的事情是很正常的。这就是为什么作为GO中的标准通用实践，建议使用defer并处理至关重要的事情（应在功能/方法内处理）。

更新的实现可能也可能看起来像是

func (eng *Engine) Suspender(ctx context.Context, wg *sync.WaitGroup) error {
    defer wg.Done()

// ------------------------------------

func (eng *Engine) Watcher(ctx context.Context, wg *sync.WaitGroup) error {
    defer wg.Done()
    contextLogger := eng.logger.WithFields(log.Fields{

另一个建议，查看主要例程，始终建议通过值将上下文传递给被调用的任何GO-ROUTINE或方法调用（Lambda）。
这种方法使开发人员摆脱了许多与程序相关的错误，这些错误无法轻易注意到。

go func(ctx context.Context) {
    err := eng.Watcher(ctx, wg)
    if err != nil {
        cancel()
    }
}(ctx)

EDIT-1 ：（精确解决方案）

尝试使用前面提到的GO例程中的值传递上下文。否则，两个GO例程都将使用单个上下文（因为您是在引用它），并且只会触发一个ctx.done（）。
通过传递CTX作为值2在GO中创建单独的子上下文。并且在用cancel（）结束父母时 - 两个孩子都独立发射ctx.done（）。