context ਪੈਕੇਜ ਦਾ ਕੀ ਮਕਸਦ ਹੈ?

Question

Accepted Answer

**`context`** ਪੈਕੇਜ **cancellation ਸਿਗਨਲ, deadlines, ਅਤੇ request-scoped values** ਨੂੰ API boundaries ਅਤੇ goroutines ਦੇ ਪਾਰ ਲਿਜਾਂਦਾ ਹੈ। ਇਹ ਅਪਰੇਸ਼ਨ ਦੀ lifetime ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਦਾ ਸਟੈਂਡਰਡ ਮੈਕਾਨਿਜ਼ਮ ਹੈ — ਖ਼ਾਸ ਕਰਕੇ work ਨੂੰ cancel ਕਰਨ ਅਤੇ timeouts ਨੂੰ function calls ਦੀ ਇੱਕ chain ਵਿੱਚੋਂ ਪਾਸ ਕਰਨ ਲਈ।

## ਇਹ ਮੁੱਖ ਸਮੱਸਿਆ ਹੱਲ ਕਰਦਾ ਹੈ

```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 ਲਿਆਉਂਦੇ ਹਨ ਜਿਸ ਨੂੰ cancel ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ; ਤੁਹਾਨੂੰ `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 ਹਰ ਇੱਕ 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` ਪੈਕੇਜ robust, production-grade Go services ਲਿਖਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ — ਇਹ goroutines ਅਤੇ API boundaries ਵਿੱਚੋਂ **cancellation ਅਤੇ timeouts** ਨੂੰ ਹੈਂਡਲ ਕਰਨ ਦਾ ਸਟੈਂਡਰਡ, idiomatic ਤਰੀਕਾ ਹੈ।

ਇਸਦੀ ਮੁੱਖ ਕੀਮਤ ਬੇਮਤਲਬ ਕੰਮ ਅਤੇ ਸਰੋਤ ਲਿਕ ਨੂੰ ਰੋਕਣਾ ਹੈ: ਜਦੋਂ ਕੋਈ ਕਲਾਇਂਟ ਡਿਸਕਨੈਕਟ ਹੋ ਜਾਏ, ਇੱਕ deadline ਗੁਜ਼ਰ ਜਾਏ, ਜਾਂ ਇੱਕ ਸਰਵਰ ਬੰਦ ਹੋ ਜਾਏ, context cancellation ਸਿਗਨਲ ਫੈਲਾ ਦਿੰਦਾ ਹੈ ਤਾਂ ਜੋ ਸਾਰੇ goroutines ਅਤੇ operations ਜੋ ਉਸ request ਲਈ ਸ਼ੁਰੂ ਕੀਤੇ ਗਏ ਸਨ ਤੁਰੰਤ ਰੁਕ ਜਾਣ ਬਜਾਏ ਬੇਮਤਲਬ ਚਲਦੇ ਰਹਿਣ ਦੇ (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 ਨੂੰ ਥ੍ਰੈਡ ਕਰਨ ਦਾ ਮੁਤਾਬਕ ਸਮਝਣਾ ਕਿਸੇ ਵੀ ਗੰਭੀਰ Go backend ਕੰਮ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਅਤੇ ਇੱਕ ਆਮ interview ਵਿਸ਼ਾ ਹੈ।