context package کس کے لیے استعمال ہوتا ہے؟

Question

Accepted Answer

**`context`** package **cancellation signals، deadlines، اور request-scoped values** کو API boundaries اور goroutines کے پار لے جاتا ہے۔ یہ operations کی lifetime کو کنٹرول کرنے کا standard mechanism ہے — خاص طور پر کام کو cancel کرنے اور timeouts کو function calls کی chain کے ذریعے propagate کرنے کے لیے۔

## وہ core problem جو یہ حل کرتا ہے

```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 derive کرتے ہیں جو cancel کیا جا سکتا ہے؛ آپ کو `defer cancel()` کے ذریعے اس کے resources کو آزاد کرنا ضروری ہے۔

## 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()` کو check کرتے ہیں (ایک channel جو cancellation پر بند ہو جاتا ہے) اور فوری روک جاتے ہیں — یہی وہ طریقہ ہے جس سے cancellation واقعی propagate ہوتی ہے۔

## Call chain کے ذریعے context پاس کرنا (یہ convention ہے)

```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 ہر layer تک پہنچے (جس میں 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 robust، production-grade Go services لکھنے کے لیے fundamental ہے — یہ **cancellation اور timeouts** کو goroutines اور API boundaries کے پار سنبھالنے کا standard، idiomatic طریقہ ہے۔

اس کی بنیادی value یہ ہے کہ یہ غیر ضروری کام اور resource leaks سے بچاتا ہے: جب کوئی client disconnect ہو، deadline گزر جائے، یا server بند ہو، تو context cancellation signal propagate کرتا ہے تاکہ اس request کے لیے spawn کیے گئے تمام goroutines اور operations فوری روک جائیں بجائے اس کے کہ بیکار چلتے رہیں (goroutine leaks کے خلاف ایک اہم دفاع)۔

یہ real Go میں سرہ ہے — HTTP servers، database calls، gRPC، اور اکثر networked libraries اپنے پہلے parameter کے طور پر `context.Context` قبول کرتی ہیں۔

Contexts بنانا (`WithTimeout`/`WithCancel`)، cancellation کے لیے جواب دینا (`<-ctx.Done()`)، `cancel()` کو ضروری طور پر call کرنا، اور call chains کے ذریعے context thread کرنے کی convention کو سمجھنا کسی بھی سنجیدہ Go backend کے کام کے لیے ضروری ہے اور یہ interview میں عام موضوع ہے۔