WaitGroup pattern for fan-out goroutines

Launching multiple goroutines and needing to wait for all of them to finish before proceeding is a common pattern without a clean built-in solution beyond WaitGroup.

Use sync.WaitGroup with Add before launching and Done in the goroutine:

func processAll(items []Item) {
    var wg sync.WaitGroup

    for _, item := range items {
        wg.Add(1)
        go func(it Item) {
            defer wg.Done()
            process(it)
        }(item)
    }

    wg.Wait() // blocks until all goroutines call Done
}

// With error collection
func processAll(items []Item) error {
    var (
        wg   sync.WaitGroup
        mu   sync.Mutex
        errs []error
    )
    for _, item := range items {
        wg.Add(1)
        go func(it Item) {
            defer wg.Done()
            if err := process(it); err != nil {
                mu.Lock()
                errs = append(errs, err)
                mu.Unlock()
            }
        }(item)
    }
    wg.Wait()
    return errors.Join(errs...)
}

WaitGroup uses an internal counter. Add increments it, Done decrements it, and Wait blocks until the counter reaches zero. The counter must never go negative.