
Timeouts in Go are built on `select` and channels. `time.After(d)` returns a channel that sends after duration `d` - combine it with a `select` to bail out if an operation takes too long.

<ExamplePair>
<ExampleProse>

Wait up to one second for a result. If the result does not arrive in time, the `time.After` case fires and the program continues without it.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    c1 := make(chan string, 1)
    go func() {
        time.Sleep(2 * time.Second)
        c1 <- "result 1"
    }()

    select {
    case res := <-c1:
        fmt.Println(res)
    case <-time.After(1 * time.Second):
        fmt.Println("timeout 1")
    }

    c2 := make(chan string, 1)
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "result 2"
    }()

    select {
    case res := <-c2:
        fmt.Println(res)
    case <-time.After(3 * time.Second):
        fmt.Println("timeout 2")
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

For cancellable timeouts - where you want to clean up the timer if the operation succeeds - use `time.NewTimer` with explicit `Stop`:

</ExampleProse>
<ExampleCode>

```go
timer := time.NewTimer(2 * time.Second)
defer timer.Stop() // cancel if we return early

select {
case result := <-work:
    fmt.Println("got result:", result)
case <-timer.C:
    fmt.Println("timed out")
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

For network requests and service calls, `context.WithTimeout` is the standard approach - it propagates the deadline through the entire call stack:

</ExampleProse>
<ExampleCode>

```go
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.com", nil)
resp, err := http.DefaultClient.Do(req)
if err != nil {
    // errors.Is(err, context.DeadlineExceeded) is true on timeout
    fmt.Println("request failed:", err)
    return
}
defer resp.Body.Close()
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always set timeouts on outbound network calls. The zero-timeout default in `net/http` has caused countless production incidents where a slow downstream service held goroutines open indefinitely. Use `http.Client{Timeout: ...}` or wrap requests in a context with deadline via `context.WithTimeout`. `time.After` leaks a timer if the channel is never drained and the timeout never fires - prefer `time.NewTimer` with `Stop()` in long-running loops or hot paths to avoid timer accumulation.
</InProduction>


Bound how long you wait for a channel operation using time.After or context.WithTimeout inside a select.

Timeouts


By adding a `default` case to a `select`, a channel operation becomes non-blocking - if no channel is ready the `default` runs immediately, and the goroutine is never suspended.

<ExamplePair>
<ExampleProse>

Try to receive from `messages`. If no message is waiting, fall through to `default` without blocking.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    messages := make(chan string)
    signals := make(chan bool)

    // non-blocking receive
    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    default:
        fmt.Println("no message received")
    }

    // non-blocking send
    msg := "hi"
    select {
    case messages <- msg:
        fmt.Println("sent message", msg)
    default:
        fmt.Println("no message sent")
    }

    // multi-way non-blocking
    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    case sig := <-signals:
        fmt.Println("received signal", sig)
    default:
        fmt.Println("no activity")
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The try-send pattern is a common idiom for metric collection and event streaming - drop the event if the consumer is slow rather than blocking the producer:

</ExampleProse>
<ExampleCode>

```go
func recordEvent(ch chan<- Event, e Event) {
    select {
    case ch <- e:
        // sent
    default:
        // consumer is slow; drop rather than block
        droppedEvents.Add(1)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Non-blocking receive is useful for draining a buffered channel without risk of blocking if it is already empty:

</ExampleProse>
<ExampleCode>

```go
func drain(ch <-chan int) []int {
    var results []int
    for {
        select {
        case v := <-ch:
            results = append(results, v)
        default:
            return results // channel empty
        }
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
The try-send pattern (`select { case ch <- v: default: }`) lets a producer drop work rather than block when the consumer is slow. This is appropriate for metric collection, event streaming, or sampling where dropping under load is acceptable. For work that must not be dropped, use a bounded buffer and propagate backpressure to the caller instead - a full channel should be a signal to slow down production, not a trigger to silently discard data.
</InProduction>


Use select with a default case to attempt a channel send or receive without blocking.

Wait on multiple channel operations simultaneously - select proceeds with whichever case is ready first.