Channel Timeouts

In this lesson, explore channel timeouts through one small Go program, and connect its output to the language rules behind it.

Use select with a timer channel to bound how long a caller waits. time.NewTimer makes ownership and cleanup explicit; time.After offers a concise one-shot alternative.

A timeout stops waiting for a result; it does not necessarily stop the goroutine doing the work. Pair timeouts with cancellation when resources matter.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import (
	"fmt"
	"time"
)

func main() {
	results := make(chan int, 1)
	results <- 9
	timer := time.NewTimer(time.Hour)
	defer timer.Stop()
	select {
	case value := <-results:
		fmt.Println("Result:", value)
	case <-timer.C:
		fmt.Println("Timed out")
	}
}

Output

Result: 9

The buffered result is already available, while the timer is not. The select prints Result: 9 and stops the unused timer.

• A caller timeout is not a worker cancellation signal.
• Avoid relying on millisecond race conditions for deterministic teaching output.

Add a worker that waits on context cancellation after the timeout instead of continuing unbounded work.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Channel Timeouts in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.