Stage 3 · Build

Concurrency in Depth

Race Detector & Worker Pools

go test -race, bounded workers, backpressure, and errgroup coordination.

8 min readGo for SREBuild

Race Detector

The race detector finds data races at runtime. It instruments every memory access to detect unsynchronized reads and writes. Always run tests with -race in CI.

Using the race detector


# Run tests with race detector
go test -race ./...

# Run benchmarks with race detector
go test -race -bench=. ./...

# Run a specific test
go test -race -run TestConcurrent ./...

# Build with race detector
go build -race -o myapp ./cmd/myapp

# Run with race detector
./myapp

The race detector adds 2-10x overhead and uses 5-10x more memory. It is not for production — use it in testing and development. The overhead comes from instrumenting every memory access with thread sanitizer code.

Common Race Conditions

Gorace-condition-examples.go

48 linesLn 1, Col 1Go

The race detector catches unsynchronized map access, counter increments without atomics, and variable reads/writes without locks. Common fixes: sync.Mutex for maps, sync/atomic for counters, sync.Map for high-contention maps.

Bounded Worker Pools

Bounded worker pools limit concurrent goroutines. This prevents resource exhaustion and provides natural backpressure.

Goworker-pool-patterns.go

67 linesLn 1, Col 1Go

Channel-based pools are explicit — jobs go in, results come out. Semaphore pools are implicit — they control concurrency without explicit job/result channels. Choose based on whether you need result ordering or collection.

Backpressure

Backpressure slows down producers when consumers are overwhelmed. Without backpressure, producers can exhaust memory or overwhelm downstream services.

Gobackpressure-patterns.go

53 linesLn 1, Col 1Go

Bounded channels provide natural backpressure — the producer blocks when the buffer is full. Semaphores limit concurrency — the producer blocks when all slots are used. Both prevent resource exhaustion.

errgroup Coordination

errgroup coordinates goroutine groups with error handling, concurrency limits, and context cancellation.

Goerrgroup-patterns.go

71 linesLn 1, Col 1Go

SetLimit bounds concurrency. Wait blocks until all goroutines finish and returns the first error. errgroup.WithContext creates a context that is canceled when any goroutine returns an error. This stops other goroutines immediately.

Testing Concurrent Code

Goconcurrent-test-patterns.go

35 linesLn 1, Col 1Go

Concurrent tests exercise multiple code paths simultaneously. The race detector catches data races. goleak catches goroutine leaks. Always run concurrent tests with -race to detect hidden synchronization issues.

Always test with -race in CI

The race detector is the most reliable way to find data races. Run every test suite with -race in CI. The overhead is acceptable for tests. Never ship code that has not been tested with the race detector.

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