go-expert

Go Concurrency Correctness

Race conditions and goroutine leaks are the Go bugs that pass every test run and only surface under load, months later. go-service-idioms covers composing concurrent work with errgroup; this skill covers the lower-level ownership rules that make individual goroutines, mutexes, and channels safe to combine that way in the first place. Apply these rules whenever code starts a goroutine, takes a lock, or closes a channel — then run the detection tooling in the last section to confirm you didn't miss one, since these bugs are usually invisible without instrumentation.

Goroutine lifecycle: every goroutine needs an owner and a stop signal

Never start a goroutine without a way to observe when it's done or tell it to stop — a context.Context, a done channel, or a sync.WaitGroup someone actually waits on.

// Bad: fire-and-forget, no one can wait for it or cancel it
go worker(items)

// Good: owned, cancelable, and its completion is observable
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() {
    defer close(done)
    worker(ctx, items)
}()

Pair every wg.Add(1) with a defer wg.Done() on the next line inside the goroutine, not somewhere later in the function body — a return or panic between Add and a non-deferred Done hangs every caller of wg.Wait() forever.

wg.Add(1)
go func() {
    defer wg.Done() // immediately, before any other logic
    process(item)
}()

Mutex hygiene: lock and defer-unlock are one atomic thought

defer mu.Unlock() goes on the line immediately after mu.Lock() — never lock, do conditional work, and defer the unlock later based on a branch. A goroutine that panics while holding a lock without a deferred unlock poisons every future caller with a permanent deadlock, since Go mutexes don't auto-release on panic.

// Bad: unlock is reachable but not guaranteed on every path
mu.Lock()
if invalid(state) {
    mu.Unlock()
    return errors.New("invalid")
}
mutate(state)
mu.Unlock()

// Good: unlock guaranteed regardless of how the function returns
mu.Lock()
defer mu.Unlock()
if invalid(state) {
    return errors.New("invalid")
}
mutate(state)