上下文包与完成的通道，避免goroutine泄漏

Question

There are two different approaches to clean up a goroutine.

1. Use a kill channel to signal cancellation and a done channel to indicate that goroutine has been terminated.

   type Worker struct {
     Done chan struct{}
     Kill chan struct{}
     Jobs chan Job
   }
   
   func (w *Worker) Run() {
     defer func() {
       w.Done <- struct{}{}
     }
     for {
       select {
       case <-w.Kill:
         return
       case j := <-w.Jobs:
         // Do some work
     }
   }
   
   go w.Run()
   w.Kill <- struct{}{}
   

2. Use context to cancel

   type Worker struct {
     Ctx context.Context
     Cancel context.CancelFunc
     Jobs chan Job
   }
   
   func (w *Worker) Run() {
     for {
       select {
       case <-w.Ctx.Done():
         return
       case j := <-w.Jobs:
         // Do some work
     }
   }
   
   go w.Run()
   w.Cancel()
   

What are the pros/cons of each approach? Which one should I default to?

I understand that if I want to kill a tree of interconnected goroutines, I should go with context approach but let's just say I have a simple worker that doesn't start other goroutines internally.

Answer 1

Go 1.7 Release Notes

Context

Go 1.7 moves the golang.org/x/net/context package into the standard library as context. This allows the use of contexts for cancelation, timeouts, and passing request-scoped data in other standard library packages, including net, net/http, and os/exec, as noted below.

For more information about contexts, see the package documentation and the Go blog post “Go Concurrent Patterns: Context.”

---

There were problems. The context package was introduced to solve them.

Now that you have read all of the relevant documentation, What is your question?