Once the channel is closed, you cannot send additional values, otherwise it will panic. This is what you experience.
This is because you run multiple goroutines that use the same channel and send values to it. And you close the channel in each of them. And since they are not synchronized, as soon as the first goroutine reaches the point where it closes it, others can (and they will) continue to send values to it: panic!
You can close the channel only once (trying to close the already closed channel also causes panic). And you must do this when all the mountains that send values on it are executed. To do this, you need to determine when all senders are sent. An idiomatic way of detecting this is to use sync.WaitGroup .
For each initial goroutine sender, we add 1 to WaitGroup using WaitGroup.Add() . And every goroutine that is done sending values can signal this by calling WaitGroup.Done() . This is best done as a delayed statement, so if your goroutin stops abruptly (for example, panic), WaitGroup.Done() will still be called and will not leave the other gyrotings hanging (waiting for the remission of sin - the call is “absent” WaitGroup.Done() it will never come ...).
And WaitGroup.Wait() will wait for the completion of all the goroutines of the sender, and only after that and only once will it close the channel. We want to detect this "global" event and close the channel when processing the values sent to it, so we must do this in our own goroutine.
The goroutine receiver will work until the channel is closed, since we used the for ... range construct on the channel. And since it starts in the main goroutine, the program will not exit until all values are correctly accepted and processed from the channel. The for ... range construct ends until all values are received that were sent before the channel was closed.
Please note that the solution below works with the buffered and unbuffered channel also without changes (try using a buffer channel with ch := make(chan int, 100) ).
The correct solution (try on the Go Playground ):
func gen(ch chan int, wg *sync.WaitGroup) { defer wg.Done() var i int for { time.Sleep(time.Millisecond * 10) ch <- i i++ // when no more data (eg from db, or event stream) if i > 100 { break } } } func receiver(ch chan int) { for i := range ch { fmt.Println("received:", i) } } func main() { ch := make(chan int) wg := &sync.WaitGroup{} for i := 0; i < 10; i++ { wg.Add(1) go gen(ch, wg) } go func() { wg.Wait() close(ch) }() receiver(ch) }
Note:
Note that it is important that receiver(ch) executed in the main goroutine and the code waiting for WaitGroup , and closes the channel in its own (non-main) goroutine; and not vice versa. If you switch these 2, it can lead to an “early termination”, that is, not all values can be received and processed from the channel. The reason for this is that the Go program ends when the main goroutine ends (spec: Program Execution ). This does not wait for the completion of other (not main) goroutines. Therefore, if waiting and closing the channel will be in the main goroutine, after the channel is closed, the program can exit at any time, without waiting for another goroutine, which in this case will quote in order to receive values from the channel.