Go by Example: Closing Channels

Closing a channel indicates that no more values will be sent on it. This can be useful to communicate completion to the channel’s receivers.
	`package main`
	`import "fmt"`
In this example we’ll use a `jobs` channel to communicate work to be done from the `main()` goroutine to a worker goroutine. When we have no more jobs for the worker we’ll `close` the `jobs` channel.	`func main() { jobs := make(chan int, 5) done := make(chan bool)`
Here’s the worker goroutine. It repeatedly receives from `jobs` with `j, more := <-jobs`. In this special 2-value form of receive, the `more` value will be `false` if `jobs` has been `close`d and all values in the channel have already been received. We use this to notify on `done` when we’ve worked all our jobs.	`go func() { for { j, more := <-jobs if more { fmt.Println("received job", j) } else { fmt.Println("received all jobs") done <- true return } } }()`
This sends 3 jobs to the worker over the `jobs` channel, then closes it.	`for j := 1; j <= 3; j++ { jobs <- j fmt.Println("sent job", j) } close(jobs) fmt.Println("sent all jobs")`
We await the worker using the synchronization approach we saw earlier.	`<-done`
It is possible to read from an empty closed channel, but instead of waiting for a message, you will immediately return zero value of the channel’s type.	`j := <-jobs fmt.Println("no jobs to receive", j) }`

	`$ go run closing-channels.go sent job 1 received job 1 sent job 2 received job 2 sent job 3 received job 3 sent all jobs received all jobs no jobs to receive 0`
Be sure that channel is not closed when you read from it, especially when iterating over a channel. Otherwise you might get an incorrect result or even enter an infinite loop. To learn how to correctly use `range` over channels, see our next example.