Go context Package

ctx, cancel := context.WithCancel(context.Background())
defer cancel()  // always call cancel to free resources

go func() {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker stopped:", ctx.Err())
            // ctx.Err() == context.Canceled
            return
        default:
            doWork()
        }
    }
}()

// Cancel all derived goroutines when done
time.Sleep(2 * time.Second)
cancel()  // signals ctx.Done() to close

parent, cancelParent := context.WithCancel(context.Background())
defer cancelParent()

child1, cancel1 := context.WithCancel(parent)
defer cancel1()

child2, cancel2 := context.WithCancel(parent)
defer cancel2()

// Cancelling the parent cancels child1 and child2 too
cancelParent()

// child1.Err() == context.Canceled
// child2.Err() == context.Canceled

// Cancelling a child does NOT affect the parent or siblings
cancel1()
// parent.Err() == nil  (still alive)
// child2.Err() == nil  (still alive)

func fetchUser(ctx context.Context, id int) (*User, error) {
    // Apply a local timeout on top of whatever deadline the caller set
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()

    var user User
    err := db.QueryRowContext(ctx,
        "SELECT * FROM users WHERE id = $1", id,
    ).Scan(&user.ID, &user.Name)
    if err != nil {
        return nil, fmt.Errorf("fetchUser: %w", err)
    }
    return &user, nil
}

// Whichever deadline is sooner — the caller's or the local 3s — wins

type Context interface {
    // Done returns a channel that closes when the context is cancelled
    // or times out. Returns nil for Background and TODO (never closes).
    Done() <-chan struct{}

    // Err returns nil while the context is active.
    // After Done closes: context.Canceled or context.DeadlineExceeded
    Err() error

    // Deadline returns the expiry time if one is set.
    Deadline() (deadline time.Time, ok bool)

    // Value returns the value for a key set via WithValue, or nil.
    Value(key any) any
}

func processItems(ctx context.Context, items <-chan Item) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()  // Canceled or DeadlineExceeded

        case item, ok := <-items:
            if !ok {
                return nil  // channel closed normally
            }
            if err := process(item); err != nil {
                return err
            }
        }
    }
}

// Check context before expensive operations
func doWork(ctx context.Context) error {
    if err := ctx.Err(); err != nil {
        return err  // bail early, context already done
    }
    // proceed with work...
    return nil
}

// Always use an unexported custom type as the key
// so no other package can accidentally read or overwrite it
type contextKey string

const (
    keyTraceID  contextKey = "traceID"
    keyUserID   contextKey = "userID"
)

// Store a value
ctx := context.WithValue(r.Context(), keyTraceID, "abc-123")
ctx  = context.WithValue(ctx, keyUserID, 42)

// Retrieve a value — returns any, so assert the type
traceID, ok := ctx.Value(keyTraceID).(string)
if !ok {
    traceID = "unknown"
}

userID, _ := ctx.Value(keyUserID).(int)

// Define the key type privately in your package
type traceKey struct{}

// Expose typed helper functions instead of the raw key
func WithTraceID(ctx context.Context, id string) context.Context {
    return context.WithValue(ctx, traceKey{}, id)
}

func TraceID(ctx context.Context) (string, bool) {
    id, ok := ctx.Value(traceKey{}).(string)
    return id, ok
}

// Usage — callers never touch the key directly
ctx = WithTraceID(ctx, "req-789")
if id, ok := TraceID(ctx); ok {
    log.Printf("trace=%s", id)
}

func handler(w http.ResponseWriter, r *http.Request) {
    // r.Context() is cancelled when the client disconnects
    ctx := r.Context()

    // Add a per-request timeout
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    // Attach trace ID from incoming header
    ctx = WithTraceID(ctx, r.Header.Get("X-Trace-ID"))

    // Pass ctx to every downstream call
    user, err := fetchUser(ctx, 123)
    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            http.Error(w, "timeout", http.StatusGatewayTimeout)
            return
        }
        http.Error(w, "internal error", http.StatusInternalServerError)
        return
    }
    json.NewEncoder(w).Encode(user)
}

func main() {
    ctx, stop := signal.NotifyContext(
        context.Background(),
        syscall.SIGINT, syscall.SIGTERM,
    )
    defer stop()

    server := &http.Server{Addr: ":8080"}

    go func() {
        if err := server.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatal(err)
        }
    }()

    // Block until SIGINT or SIGTERM
    <-ctx.Done()
    log.Println("shutting down...")

    shutdownCtx, cancel := context.WithTimeout(
        context.Background(), 10*time.Second,
    )
    defer cancel()
    server.Shutdown(shutdownCtx)
}

func fetchAll(ctx context.Context, urls []string) ([]string, error) {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    results := make([]string, len(urls))
    errCh   := make(chan error, len(urls))
    var wg sync.WaitGroup

    for i, url := range urls {
        wg.Add(1)
        go func(i int, url string) {
            defer wg.Done()
            body, err := fetch(ctx, url)
            if err != nil {
                cancel()         // cancel all siblings
                errCh <- err
                return
            }
            results[i] = body
        }(i, url)
    }

    wg.Wait()
    close(errCh)
    return results, <-errCh
}