Why is my "done" channel closing randomly? - go

Question

I built the following go code.
The idea is to build a done channel and a generator that generates a channel of int.
Link them in a 2 stage pipe
chanNumbers := pipeb(done, pipea(done, gen(done)))
After some seconds, cancel the done channel.
I expect to see the generator and two stage of the pipe to cancel and return, but the text "PipeX is terminating now" only appears randomly and I really do not understand why.
Would someone have an idea?
package main
import (
"fmt"
"time"
)
func gen(done <-chan interface{}) <-chan int {
ret := make(chan int)
cx := 0
go func() {
for {
select {
case <-done:
fmt.Println("**Generator Terminates now")
time.Sleep(2 * time.Second)
fmt.Println("**Generator has terminated now")
close(ret)
return
case ret <- cx:
fmt.Printf("Gen : we push %d \n", cx)
cx = cx + 1
}
}
}()
fmt.Println("Generator has created and returned its channel")
return ret
}
func pipea(done <-chan interface{}, in <-chan int) <-chan int {
ret := make(chan int)
go func() {
for {
select {
case <-done:
fmt.Println("**pipeA terminates")
time.Sleep(2 * time.Second)
fmt.Println("**pipeA has terminated now")
close(ret)
return
case tmp, ok := (<-in):
if ok {
fmt.Printf("pipeA : we push %d \n", tmp)
ret <- tmp
} else {
in = nil
}
}
}
}()
return ret
}
func pipeb(done <-chan interface{}, in <-chan int) <-chan int {
ret := make(chan int)
go func() {
for {
select {
case <-done:
fmt.Println("**pipeB terminates")
time.Sleep(2 * time.Second)
fmt.Println("**pipeB has terminated now")
close(ret)
return
case tmp, ok := (<-in):
if ok {
fmt.Printf("pipeB : we push %d \n", tmp)
ret <- tmp
} else {
in = nil
}
}
}
}()
return ret
}
func main() {
done := make(chan interface{})
chanNumbers := pipeb(done, pipea(done, gen(done)))
go func() {
time.Sleep(2 * time.Second)
close(done)
}()
forloop:
for {
select {
case n := <-chanNumbers:
fmt.Printf("Received in main element : %d\n", n)
case <-done:
break forloop
}
}
//end of the main program
fmt.Println("Sleeping some seconds before termiating")
time.Sleep(8 * time.Second)
fmt.Println("exit...")
}

Answer 1

You have four go-routines running:
gen, your generator, writing to an unbuffered output channel until done
pipeA, reading from gen, writing to an unbuffered output channel until done
pipeB, reading from pipeA, writing to an unbuffered output channel until done
main, reading from pipeB until done
Now when you close done, it totally depends on the order in which the go-routines see that.
If main is the first to see that done is closed, it will break the for-loop and stop consuming from pipeB. But if pipeB is still trying to write to the output channel (ret <- tmp), it will block there; so it will never get to the <- done part.
There are two options to fix this:
Only listen to done in your generator, and have the other go-routines use for n := range in { }.
Put your sending logic in a select as well so your generator and pipes can detect when done is closed.
Alternatively, you might want to use buffered output channels, but even then this problem can still occur.