5. Closing Channels in Go

Channels can be explicitly closed by a sender:

ch := make(chan int)

// do some stuff with the channel

close(ch)

Checking If a Channel Is Closed

Similar to the ok value when accessing data in a map, receivers can check the ok value when receiving from a channel to test if a channel was closed.

v, ok := <-ch

ok is false if the channel is empty and closed.

Don't Send on a Closed Channel

Sending on a closed channel will cause a panic. A panic on the main goroutine will cause the entire program to crash, and a panic in any other goroutine will cause that goroutine to crash.

Closing isn't necessary. There's nothing wrong with leaving channels open; they'll still be garbage collected if they're unused. You should close channels to indicate explicitly to a receiver that nothing else is going to come across.

Assignment

At Textio we're all about keeping track of what our systems are up to with great logging and telemetry.

The sendReports function sends out a batch of reports to our clients and reports back how many were sent across a channel. It closes the channel when it's done.

Complete the countReports function. It should:

• Use an infinite for loop to read from the channel

• If the channel is closed, break out of the loop

• Otherwise, keep a running total of the number of reports sent

• Return the total number of reports sent

Solution

package main

func countReports(numSentCh chan int) int {
	total := 0

	for{
		v,ok:= <- numSentCh
		if !ok{
			break
		}else{
			total += v
		}
		
	}

	return total
}

// don't touch below this line

func sendReports(numBatches int, ch chan int) {
	for i := 0; i < numBatches; i++ {
		numReports := i*23 + 32%17
		ch <- numReports
	}
	close(ch)
}

Explanation

What is inside numSentCh?

Look at sendReports:

func sendReports(numBatches int, ch chan int) {
	for i := 0; i < numBatches; i++ {
		numReports := i*23 + 32%17
		ch <- numReports
	}
	close(ch)
}

This line is the key:

ch <- numReports

That means:

Send the integer numReports into the channel.

So the channel contains ints.

Each int represents:

The number of reports sent in one batch.

Is the channel like an array?

Not exactly.

It behaves like a stream.

Think of it like a pipe.

• sendReports pushes numbers into one end

• countReports reads numbers out the other end

• When close(ch) happens, no more numbers will come

It is NOT an array. It is not stored. It is not indexed. You can only read the next value.

What is v?

In this line:

v, ok := <-numSentCh

This means:

• Read the next value from the channel

• Store it in v

• Store whether the channel is still open in ok

So:

• v is the integer that was sent

• ok is true if the channel is still open

• ok is false if the channel is closed and empty

Example of What’s Actually Happening

Let’s say:

sendReports(3, ch)

The loop runs 3 times:

When i = 0:

numReports = 0*23 + 32%17
32%17 = 15
numReports = 15

When i = 1:

1*23 + 15 = 38

When i = 2:

2*23 + 15 = 61

So the channel receives:

15
38
61

Then it closes.

What countReports sees

When reading from the channel:

First iteration: v = 15 Second: v = 38 Third: v = 61 Then: ok = false (channel closed)

What are we adding to total?

We do:

total += v

So we are adding:

15 + 38 + 61

Which equals:

114

So countReports returns the total number of reports sent across all batches.

Mental Model

sendReports --> [ 15 ] --> [ 38 ] --> [ 61 ] --> close
                  ^
                  |
           countReports reads one at a time

Every time you do:

v := <-numSentCh

You’re grabbing the next number in the pipe.

Frequently Asked Questions

Is `v` representing a total number of reports sent in one batch?

Yes. Each v is the number of reports sent in that single batch.

Is `numSentCh` like an array?

No. It’s a stream of integers sent one at a time through a pipe.