Stage 3 · Build

Concurrency in Depth

select, Timeouts & Tickers

select fairness, time.After pitfalls, ticker cleanup, and non-blocking operations.

7 min readGo for SREBuild

select Fairness

When multiple select cases are ready, Go chooses one randomly. This prevents starvation — no goroutine is permanently skipped. Understanding this behavior is critical for writing correct concurrent code.

Goselect-random-selection.go

25 linesLn 1, Col 1Go

Go's select statement does not bias toward any case. When both channels are ready, it picks one at random. This is a fairness guarantee that prevents one goroutine from monopolizing the select.

time.After Pitfalls

time.After creates a new timer each time it is called. In a loop, this leaks timers and consumes memory. Use time.NewTimer and reset instead.

Gotime.after-leak-vs-safe-pattern.go

44 linesLn 1, Col 1Go

time.After creates a new timer that is not garbage collected until it fires. In tight loops, this leaks thousands of timers. time.NewTimer with Reset is efficient. context.WithTimeout is the most idiomatic approach.

Timeout Patterns

Timeouts prevent goroutines from blocking forever. The standard pattern uses context.WithTimeout or time.AfterFunc.

Gotimeout-implementations.go

45 linesLn 1, Col 1Go

Context timeout is the most common pattern. It propagates through the call stack and integrates with standard libraries. time.AfterFunc is useful for fire-and-forget timeouts. The timeout channel pattern is simple but leaks timers.

Ticker Patterns

Tickers fire at regular intervals. Use them for periodic tasks: health checks, metrics collection, cache refreshes. Always stop tickers to prevent leaks.

Goticker-usage.go

57 linesLn 1, Col 1Go

time.NewTicker creates a ticker that fires at the specified interval. defer ticker.Stop() prevents the ticker goroutine from leaking. Jittered tickers prevent thundering herd when many instances run the same periodic task.

Non-Blocking Operations

Non-blocking channel operations use select with default. They attempt a send or receive and return immediately if it would block.

Gonon-blocking-patterns.go

42 linesLn 1, Col 1Go

Non-blocking operations are useful for polling, checking channel state, and implementing backpressure. They return immediately without blocking the goroutine. Use them when you need to do other work between channel attempts.

Deadline Patterns

Deadlines are absolute timeouts. They propagate through context chains and ensure operations complete by a specific time.

Godeadline-propagation.go

30 linesLn 1, Col 1Go

context.WithDeadline sets an absolute time. context.WithTimeout sets a relative time. Both create a deadline that propagates through the context chain. ctx.Err() returns DeadlineExceeded when the deadline passes.

Prefer context for timeouts

context.WithTimeout and context.WithDeadline are preferred over time.After because they integrate with the standard library, propagate through call chains, and support cancellation. Use time.After only for simple, one-shot timeouts.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.