Stage 3 · Build

Concurrency in Depth

Goroutine Lifecycle

Spawn costs, leaks, ownership, and detecting blocked goroutines with stack dumps.

7 min readGo for SREBuild

Goroutine Creation

Goroutines are cheap — they start at a few KB of stack and grow as needed. But they are not free. Each goroutine consumes memory, CPU time for scheduling, and GC overhead. Creating millions of goroutines is a bug, not a feature.

Gogoroutine-cost.go

15 linesLn 1, Col 1Go

runtime.NumGoroutine() returns the current goroutine count. Monitor this metric — a growing count indicates leaks. Each goroutine has at least 2KB stack space, so 1M goroutines = 2GB minimum.

Ownership Model

Every goroutine needs a clear owner. The owner is responsible for starting the goroutine and ensuring it stops. Without ownership, goroutines leak because nobody is responsible for stopping them.

Goownership-patterns.go

44 linesLn 1, Col 1Go

Ownership means one entity starts goroutines and one entity stops them. errgroup provides clear ownership — g.Wait() blocks until all goroutines finish. context.WithCancel ensures cleanup on cancellation.

Goroutine Leaks

A goroutine leak is a goroutine that runs forever because it is waiting on a channel that will never receive, or a context that will never be canceled.

Gocommon-leak-patterns.go

50 linesLn 1, Col 1Go

Every goroutine must have an exit path. Channel receives must be paired with a context cancellation case. Channel sends must have a receiver or a context cancellation case. Missing any of these creates a leak.

Detecting Leaks

Detect leaks in tests with goleak, in production with runtime.NumGoroutine(), and in debugging with stack dumps.

Goleak-detection-in-tests.go

29 linesLn 1, Col 1Go

goleak automatically detects goroutine leaks in tests. VerifyTestMain catches leaks across all tests. VerifyNone catches leaks in individual tests. Manual detection with NumGoroutine() is useful for ad-hoc checks.

Stack Dumps

Stack dumps show where every goroutine is blocked. This is the most powerful tool for debugging goroutine leaks and deadlocks.

Gotriggering-a-stack-dump.go

25 linesLn 1, Col 1Go

SIGQUIT (Ctrl+\) dumps all goroutine stacks. runtime.Stack with all=true dumps every goroutine. The pprof endpoint provides the same information via HTTP. Look for goroutines blocked on channel operations — these are likely leaks.

Best Practices

Always provide an exit path for every goroutine
Use context cancellation as the primary shutdown mechanism
Monitor runtime.NumGoroutine() in production
Use goleak in tests to catch leaks early
Use errgroup for managed goroutine groups
Set goroutine limits with errgroup.SetLimit or semaphores
Document goroutine ownership in code comments

Goroutine lifecycle = context lifecycle

The most reliable pattern is tying goroutine lifetime to context lifetime. When the context is canceled, the goroutine exits. This creates a clear, testable lifecycle for every goroutine.

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