context பேக்கேஜ் எதற்காக பயன்படுத்தப்படுகிறது?

Question

Accepted Answer

**`context`** பேக்கேஜ் **cancellation signals, deadlines, மற்றும் request-scoped values** ஐ API boundaries மற்றும் goroutines முழுவதாக கொண்டு செல்கிறது. இது operations இன் lifetime ஐ கட்டுப்படுத்துவதற்கான தரமான mechanism ஆகும் — குறிப்பாக work ஐ 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 இனை free செய்ய.

## 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()` ஐ சரிபார்க்கிறது (cancellation இல் close ஆகும் channel) மற்றும் உடனே நிறுத்துகிறது — இதுவே cancellation எவ்வாறு actually propagate ஆகிறது.

## Call chain முழுவதாக context ஐ pass செய்தல் (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 ஆக flow ஆகிறது, எனவே cancellation ஒவ்வொரு layer க்கும் (context ஐ accept செய்யும் standard-library DB/HTTP calls உட்பட) அடைகிறது.

## Request-scoped values (மிகவும் sparingly பயன்படுத்தவும்)

```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 எழுதுவதற்கு அடிப்படையாக உள்ளது — இது **cancellation மற்றும் timeouts** ஐ goroutines மற்றும் API boundaries முழுவதாக handle செய்ய standardized, idiomatic way ஆகும்.

இதன் primary value என்பது வீணான work மற்றும் resource leaks ஐ தடுப்பது: ஒரு client disconnect ஆகும் போது, deadline pass ஆகும் போது, அல்லது ஒரு server shutdown ஆகும் போது, context cancellation signal ஐ propagate செய்கிறது இதனால் அந்த request க்கு spawned ஆன அனைத்து goroutines மற்றும் operations uselessly run செய்யாமல் உடனே stop ஆகிறது (goroutine leaks க்கு எதிரான key defense).

இது real Go இல் pervasive ஆக உள்ளது — HTTP servers, database calls, gRPC, மற்றும் பெரும்பாலான networked libraries அவற்றின் முதல் parameter ஆக `context.Context` ஐ accept செய்கிறது.

Contexts உ்ற்பத்தி செய்வது (`WithTimeout`/`WithCancel`), cancellation க்கு பதிலளிப்பது (`<-ctx.Done()`), must-call-`cancel()` rule, மற்றும் call chains முழுவதாக context ஐ threading செய்வதன் convention ஆகியவற்றை புரிந்து கொள்வது எந்த serious Go backend work க்கும் அவசியமாக உள்ளது மற்றும் ஒரு common interview topic ஆகும்.