Concurrency Patterns

A worker pool is a fixed set of goroutines that all receive from one jobs channel and run tasks concurrently. You launch N goroutines, each ranging over the channel; a producer sends jobs and then closes it, which makes every worker's range loop end.

Use a buffered channel of capacity N as a counting semaphore: send a token (sem <- struct{}{}) before starting work and receive one when done. The send blocks once N tokens are in flight, so no more than N goroutines run at the same time.

Use a sync.Mutex to guard mutable state updated in place — a counter, cache, or map — cheap for short critical sections. Use a channel to transfer ownership and coordinate goroutines. Both give happens-before; the choice is cost, not safety.

An errgroup.Group is like a WaitGroup, but Go captures the first non-nil error and Wait returns it. WithContext cancels its context on that error so siblings stop early, and SetLimit bounds concurrency. It returns only the first error.

Launch one goroutine per name, each timing testSearcher(ctx, name) and sending a {name, dur, err} result to a buffered channel that a closer goroutine closes after a WaitGroup. Range the channel, keep the result with the smallest dur among successes, and propagate ctx so cancellation stops in-flight probes. If all fail, return the last error.

Reuse one http.Client (never one per request) and tune its Transport: MaxConnsPerHost caps connections to a host, MaxIdleConnsPerHost keeps warm ones for reuse, and IdleConnTimeout reaps idle ones. Untuned, a burst of goroutines opens unbounded sockets and exhausts ephemeral ports. Pair it with a semaphore to also bound in-flight requests.

The defer resp.Body.Close() runs after io.ReadAll, and the earlier if err != nil returns leave the body unclosed on the error path. Move the defer resp.Body.Close() to immediately after the Get error check, so every successful Get closes the body and frees the connection.

On Go 1.22+ each iteration gets its own v, so the goroutines print 1 2 3 in some order. On Go ≤1.21 they all shared one v mutated by the loop and typically printed 3 3 3. The portable fix is v := v inside the loop or passing v as an argument.

For CPU-bound work, size the pool to runtime.NumCPU() — extra goroutines beyond the cores only add scheduling cost. Send indices over a jobs channel; each worker writes out[i] = heavyCompute(nums[i]) to its own index, so no lock is needed and order is preserved. A sync.WaitGroup blocks until every worker finishes.

Use two signal channels as a ping-pong: the odd goroutine waits on <-odd, prints, then signals even <- struct{}{}; the even goroutine mirrors it. main kicks off with odd <- struct{}{} and waits on a done channel the even goroutine closes after N. The hand-off enforces strict ordering with no shared state.

Launch one goroutine per supplier, each calling SearchRPC(ctx, …) and sending results to a buffered channel; a sync.WaitGroup plus a closer goroutine closes it after all finish. Aggregate by ranging the channel, and propagate ctx so a timeout cancels every in-flight RPC instead of waiting.

Use the func Main() error pattern: main just does if err := Main(); err != nil { log.Fatal(err) }. Inside Main, after each successful init register a defer that runs cleanup and folds any cleanup error into the named return with errors.Join. Defers run LIFO, so Service.Stop runs before SendQueue.Close. This works because log.Fatal calls os.Exit, which skips defers, so they must live in Main, not main.

A goroutine that does ch <- result after the receiver has already returned (e.g. on an early error or a hit deadline) blocks forever on the send, leaking. Fix it with a select over the send and ctx.Done(), or a buffered channel sized to the senders, so the send can never block past cancellation.

Acquire the slot with a select over both the semaphore send and ctx.Done(), so a cancelled context aborts the wait instead of blocking forever. Each running goroutine also selects on ctx.Done() to stop early and releases its token via defer, so cancellation never leaks a slot.