信号 goroutines 在通道关闭时停止

Question

我有多个select来自两个通道的goroutine ：一个 chan 提供数据，一个 chan 用于信号（一种完成/退出通道）。

我使用信号通道来捕获信号（kill）并优雅地关闭 goroutine。

我正在运行 'worker' goroutines from package a，而捕获信号的 goroutine func 从package b.

我使用来自https://gist.github.com/reiki4040/be3705f307d3cd136e85的信号包。

package a

import "sync"

WorkChan := make(chan int)
QuitChan := make(chan struct{})

func Stop() {
        fmt.Println("Stop called, closing channel")
        close(QuitChan)
}

func Work(wg *sync.WaitGroup) {
    var item int
    for {
        select {
        case item = <- WorkChan:
            ... processing
        case <- QuitChan:
            wg.Done()
            return
        }
    }
}

捕捉信号并调用的 goroutine a.Stop()

package b

import (
    "os/signal"
    "os"
    "syscal"
    "a"
)

func Signal() {

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

    for {
        s := <-sChan
        switch s {
        case os.Interrupt, syscall.SIGTERM:
            a.Stop()
        }
    }
}

这是我的主要功能

package main

import (
    "a"
    "b"
    "sync"
)

func main() {

    var wg sync.WaitGroup

    go b.Signal()

    wg.Add(1) // for simplicity; actual code start multiple goroutines of Work
    go a.Work(&wg)

    // wait until work is done
    wg.Wait()
    fmt.Println("Done.")
}

当我终止正在运行的进程时，我看到来自Quit. 我预计，一旦通道被关闭，够程会select在QuitChan一些点和回报情况。

但他们继续奔跑；他们继续处理来自 的项目WorkChan。似乎被忽略了。我在这里缺少什么？通道不是关闭了吗？怎么还开着？

Answer 1

首先我觉得你应该做一个简单的测试，然后把它过去。让其他人了解您的问题会更有帮助。

我改变了你的代码，让它读起来像一个 go 代码，而不是其他语言。现在它起作用了。

在您的代码中，有一些错误，我将其标记为 ERROR 注释。有些是语法错误，比如创建WorkChan. 有些是类型错误。

你应该知道的一件导入设计的事情，当你想在执行后退出时Stop()，你应该关闭WorkChan你发送数据的地方WorkChan，窃取你收到的日期。

• 前

  package a
  
  import (
      "fmt"
      "sync"
  )
  
  // ERROR: can not do make in global
  var WorkChan chan int
  var QuitChan chan struct{}
  
  // Create chan when init
  func init() {
      fmt.Println("Init a")
      WorkChan = make(chan int)
      QuitChan = make(chan struct{})
  }
  
  func Stop() {
      fmt.Println("Stop called, closing quit channel")
      close(QuitChan)
  }
  
  // Close the work channel where you send date
  func Start(wg *sync.WaitGroup) {
      i := 0
      for {
          select {
          case <-QuitChan:
              fmt.Println("Closing work chan")
              close(WorkChan)
              wg.Done()
              return
          default:
              WorkChan <- i
              i++
          }
      }
  }
  
  // Work will exit when workchan closed
  func Work(wg *sync.WaitGroup) {
      for item := range WorkChan {
          fmt.Printf("Receive %d\n", item)
      }
      wg.Done()
      fmt.Println("Work exit")
  }
  

• b. 去

  package b
  
  import (
      "github.com/shitaibin/awesome/a"
      "os"
      "os/signal"
      "syscall"
  )
  
  func Signal() {
  
      sChan := make(chan os.Signal, 1)
      signal.Notify(sChan, syscall.SIGTERM, syscall.SIGINT) // ERROR
  
      for {
          s := <-sChan
          switch s {
          case os.Interrupt, syscall.SIGTERM:
              a.Stop()
              return // should return free resource
          }
      }
  }
  

• main.go

  package main
  
  import (
      "fmt"
      "github.com/shitaibin/awesome/a"
      "github.com/shitaibin/awesome/b"
      "sync"
  )
  
  func main() {
  
      var wg sync.WaitGroup
  
      go b.Signal()
  
      wg.Add(1)      // for simplicity; actual code start multiple goroutines of Work
      go a.Work(&wg) // ERROR: pointer
  
      wg.Add(1)
      go a.Start(&wg) // Send data and close channel when stop
  
      // wait until work is done
      wg.Wait()
      fmt.Println("Done.")
  }
  

• 结果

  // omit
  Receive 87028
  Receive 87029
  Receive 87030
  Receive 87031
  Receive 87032
  Receiv^C101    <---- send signal here
  Receive 87102
  Receive 87103
  Receive 87104
  Receive 87105
  Receive 87106
  Receive 87107
  Receive 87108
  Receive 87109
  Receive 87110
  Stop called, closing quit channel
  Receive 87111
  Receive 87112
  Closing work chan
  Work exit
  Done.