context package किसके लिए उपयोग होता है?

Question

Accepted Answer

**`context`** package **cancellation signals, deadlines, और request-scoped values** को API boundaries और goroutines के पार ले जाता है। यह operations के lifetime को नियंत्रित करने का मानक तंत्र है — खासकर काम रद्द करने और function calls की श्रृंखला के माध्यम से timeouts फैलाने के लिए।

## यह जो मुख्य समस्या हल करता है

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## contexts बनाना

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` एक child context व्युत्पन्न करते हैं जिसे रद्द किया जा सकता है; इसके संसाधनों को मुक्त करने के लिए आपको `defer cancel()` करना ही चाहिए।

## cancellation का जवाब देना

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Functions `ctx.Done()` (एक channel जो cancellation पर बंद होता है) की जाँच करते हैं और तुरंत रुक जाते हैं — cancellation वास्तव में इसी तरह फैलता है।

## call chain के माध्यम से context पास करना (परंपरा)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Context call stack में पहले parameter के रूप में नीचे बहता है, इसलिए cancellation हर परत तक पहुँचता है (standard-library DB/HTTP calls सहित जो एक context स्वीकार करते हैं)।

## request-scoped values (संयम से उपयोग करें)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

## यह क्यों महत्वपूर्ण है

`context` package मज़बूत, production-grade Go services लिखने के लिए बुनियादी है — यह goroutines और API boundaries के पार **cancellation और timeouts** को संभालने का मानक, idiomatic तरीका है।

इसका प्राथमिक मूल्य बर्बाद काम और resource leaks को रोकना है: जब एक client disconnect करता है, एक deadline गुज़रती है, या एक server बंद होता है, context cancellation signal को फैलाता है ताकि उस request के लिए spawn की गई सभी goroutines और operations बेकार में चलने के बजाय तुरंत रुक जाएँ (goroutine leaks के विरुद्ध एक मुख्य बचाव)।

यह वास्तविक Go में व्यापक है — HTTP servers, database calls, gRPC, और अधिकांश networked libraries एक `context.Context` को अपने पहले parameter के रूप में स्वीकार करते हैं।

contexts बनाना (`WithTimeout`/`WithCancel`), cancellation का जवाब देना (`<-ctx.Done()`), must-call-`cancel()` नियम, और call chains के माध्यम से context को threading करने की परंपरा को समझना किसी भी गंभीर Go backend काम के लिए आवश्यक है और एक आम interview विषय है।