Which strategy prevents goroutine leaks when using select with buffered channels?

Answer

The most reliable way to ensure a producer terminates when the receiver is no longer active is to add a cancellation signal to the same select that performs the send, and exit the producer on that signal. Do not close the data channel from the producer and do not use a shared state variable.

select {
case out <- v:
    // sent
case <-ctx.Done():
    return
}

When the consumer is finished it cancels the context. The <-ctx.Done() case becomes ready, unblocking the producer and allowing it to return cleanly.

Confirmed facts

• A send on a buffered channel blocks when the buffer is full and no receiver is ready.
• If the consumer exits, the buffer can stay full and a producer that is blocked on out <- v will remain in memory indefinitely.
• Sending on a closed channel panics. Closing a data channel should be owned by a single writer, not by a producer that may still have work.
• A select with a default case makes the send non-blocking and will silently drop messages.

Likely explanation

Adding a second ready case to the producer’s select gives the runtime an alternative to wait on. With ctx.Done() or a dedicated quit channel in the same select, the producer can observe consumer lifetime without closing the data channel or polling shared state. The producer exits promptly on cancellation instead of waiting forever for a receiver that will never arrive.

Minimal steps for this case

1. Create a context with cancel tied to consumer lifetime, e.g., ctx, cancel := context.WithCancel(context.Background()).
2. Pass ctx to the producer. In the producer loop use select with the send case and <-ctx.Done() case.
3. Consumer calls cancel() when it stops listening. The producer unblocks on ctx.Done() and returns.
4. Do not close the data channel from the producer side.

Cancellation must be propagated to all producers sharing the channel, otherwise some goroutines may still leak.