AdvancedConcurrency

Lab: concurrency patterns

Scenario questions on goroutine leaks, channel direction, WaitGroup vs channels, and context cancellation.

Lab · optionalGoAdvanced15 min

Recommended first

Context

By the end of this lesson you will be able to:

Identify goroutine leak scenarios and their fixes
Read directional channel types
Choose WaitGroup vs channels for a given coordination problem
Trace context cancellation through a call chain

Optional lab. These scenarios cover the most common concurrency mistakes and patterns in production Go code. Goroutine leaks are a particularly common source of hard-to-diagnose memory growth.

Goroutine leaks

Knowledge check

1.
A goroutine sends a result to an unbuffered channel. The receiver exits early (due to a timeout) without receiving. What happens to the goroutine?
It panics because the channel is abandonedIt is leaked — blocked forever on the send with no receiverThe send is dropped and the goroutine returns normallyThe runtime cleans it up after a few seconds
2.
Which of these is the standard fix for a goroutine that could block forever on an unbuffered channel send?
Use a buffered channel with capacity 1 so the send can always completeUse a select with a done channel so the goroutine can exitBoth A and B are valid depending on the situationClose the channel before the goroutine sends

Channel direction

Knowledge check

1.
A function signature is: func produce(out chan<- int). What does chan<- mean?
out is a receive-only channel — the function can only receive from itout is a send-only channel — the function can only send to itout is a bidirectional channelThis is a syntax error — channels cannot be directional
2.
A bidirectional chan int can be passed to a function that accepts a send-only chan<- int.
TrueFalse

WaitGroup vs channels

Knowledge check

1.
You launch 10 goroutines to process independent tasks. You only need to know when all 10 are done, not their results. Which is most idiomatic?
A channel of size 10 where each goroutine sends a done signalsync.WaitGroup — Add(10), each goroutine calls Done(), Wait() at the endA global counter protected by sync.Mutextime.Sleep long enough that all goroutines should have finished
2.
You launch 10 goroutines and need to collect all their results. Which approach handles this naturally?
sync.WaitGroup onlyA channel that each goroutine sends its result to, closed after WaitGroup.Wait()A mutex-protected slice that goroutines append to, drained after WaitGroup.Wait()Both B and C are idiomatic patterns for collecting results

Context cancellation

Knowledge check

1.
A context.WithTimeout is created in an HTTP handler with a 3-second budget. The handler calls a service function, which calls a database function. The query takes 5 seconds. What happens?
The database query runs to completion and then returns an errorctx.Done() fires at 3 seconds, and any function blocking on ctx will return with DeadlineExceededOnly the HTTP handler is cancelled — inner calls are unaffectedThe context has no effect on database calls
2.
ctx.Err() returns context.Canceled when a deadline expires.
TrueFalse

A complete leak scenario

Read this code and identify the bug:

func fetchAll(ids []int) []string {
    results := make(chan string) // unbuffered
    for _, id := range ids {
        go func(id int) {
            results <- fetch(id) // goroutine sends result
        }(id)
    }

    var out []string
    for i := 0; i < 3; i++ { // reads only 3 results, not len(ids)
        out = append(out, <-results)
    }
    return out
}

If len(ids) is greater than 3, the goroutines for the extra IDs will be permanently blocked on results <- ... with no receiver — a goroutine leak. The fix is either to read all results (for i := 0; i < len(ids); i++) or to use a buffered channel (make(chan string, len(ids))).

This pattern is one of the most common concurrency bugs in Go services. Recognising it by shape is a valuable skill.

Where to go next

The next module, Production Go, moves from concurrency to the full production story: HTTP servers, JSON encoding, profiling, and building and deploying binaries.

Finished reading? Mark it complete to track your progress.

Context

Propagate cancellation and deadlines across goroutines and API boundaries with the context package.

net/http

Build HTTP servers with Go's standard library — HandleFunc, ServeMux, the Handler interface, middleware, and request/response types.

Lab: concurrency patterns

Goroutine leaks

Knowledge check

Channel direction

Knowledge check

WaitGroup vs channels

Knowledge check

Context cancellation

Knowledge check

A complete leak scenario

Where to go next

On this page