Signal goroutines to stop with channel close

Question

I have got multiple goroutines that select from two channels: one chan provides data, one chan for signals (kind of done/quit channel).

I use the signals channel to capture signals (kill) and gracefully close the goroutines.

I'm running the 'worker' goroutines from package a, while the goroutine func that captures signals runs from package b.

I use the signals package from 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
        }
    }
}

The goroutine to catch signals, and call 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()
        }
    }
}

and this is my main func

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.")
}

When I kill the running process, I see the printed message from Quit. I expected that once the channel is closed, the goroutines will select the QuitChan case at some point and return.

But they keep running; they continue to process items from WorkChan. seems like it is ignored. What am I missing here? Doesn't the channel get closed? How come it is still open?

When you close a.QuitChan, that will terminate a's goroutine (sooner or later), but the goroutine in the b package has no termination condition, that will run forever. Also, the app will not terminate just because some "random" goroutine ended, the app terminates when the main goroutine ends (we don't know what your main goroutine is). — icza
You have a loop in b's goroutine, and there is no return nor break statement in it, so it will run forever. A goroutine or its loop will not magically end or return just because an independent goroutine ended. — icza
Just because you see "Stop called, closing channel" printed, that is not guarantee that the QuitChan is closed (as the print is before the close() call). Put a print statement after the close() and confirm if you see that printed. — icza
You are copying the WaitGroup. Use a pointer instead. go vet should complain about that, I think. — Peter

James Shi James Shi · Accepted Answer · 2018-11-13T05:12:11

First I think you should make a simple test, and past it out. It will be more help to let other understand what's your problem.

I changed your code, and make it reading like a go code, instead of other language. Now it's worked.

In your code, there are some mistakes, I marked it as ERROR comment. Some are grammar error, like creating WorkChan. Some are type error.

One import design thing you should know, when you want exit after execute Stop(), you should close the WorkChan where you send data to WorkChan, insteal of just return at where you receive date.

a.go

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.go

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.")
}

Result

// 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.

Signal goroutines to stop with channel close

1 Answers