default and Non-Blocking Operations

## What `select` does without a `default` A `select` statement lists several channel operations — sends, receives, or both — and performs exactly one of them. The runtime looks at all the cases and asks, for each, "can this communication proceed right now?" A receive can proceed if a sender is waiting, if the channel's buffer holds a value, or if the channel is closed. A send can proceed if a receiver is waiting or the buffer has room. - If **exactly one** case can proceed, it is chosen. - If **several** can proceed, one is chosen **uniformly at random** — not by source order. - If **none** can proceed, the select **blocks**: the goroutine is parked and consumes no CPU until one of the channels becomes ready. That last line is the default behaviour and it is usually what you want. A parked goroutine is cheap; it costs a little memory and nothing else. ## What adding `default` changes ```go select { case v := <-ch: use(v) default: // nothing was ready this instant } ``` The first two bullets above are unchanged. Only the third is replaced: instead of parking the goroutine, the runtime executes the `default` body and the select finishes. The select becomes a **non-blocking probe** — an attempt that either succeeds now or gives up now. Three points people get wrong: 1. **`default` is not a fallback for the other cases.** It does not mean "if the receive fails, do this instead". The receive never "fails"; it is either ready or not ready, and only *not ready* reaches `default`. 2. **`default` does not wait.** There is no grace period, no retry, no short timeout. If you want a timeout you need a timer channel as one of the *cases*, not a `default`. 3. **`default` does not change the random choice.** If two real cases are both ready, `default` has no effect at all on which one runs. ## Syntax rules A select may have **at most one** `default` clause; two is a compile-time error. Its position among the cases has no meaning — `default` written first behaves exactly like `default` written last, because cases are not scanned in order. An empty `select {}` with no cases and no default blocks forever; `select { default: }` with only a default is a no-op that returns immediately. ## Why it exists The non-blocking form buys you the ability to *make progress even when a communication is not possible*. Typical uses: - **Try-send**: offer a value to a channel and carry on if nobody can take it right now. - **Try-receive**: pick up work if any is waiting, otherwise do something else. - **Checking a signal without waiting for it**: probe a cancellation channel in the middle of a long computation without stopping the computation when it has not fired. ## The cost you must respect Because the select never waits, a `for` loop whose only select has a `default` case never yields to anything. It becomes a spin loop: the goroutine runs flat out, saturating one CPU core, doing no useful work while it waits for something to appear. A blocking select costs zero CPU while idle; a select with `default` inside a bare loop costs an entire core. The rule of thumb is that `default` belongs in code that is *already going to do something else* on this pass — not in a loop whose only purpose is to wait. ## A quick mental model Without `default`, the goroutine is a person sitting by the phone: asleep, costing nothing, woken when it rings. With `default`, the goroutine is a person walking past the phone, glancing at it, and continuing. Doing that once per pass through real work is fine. Doing it in a tight loop is how you burn a core to check an empty phone ten million times a second.