context package దేనికి ఉపయోగించబడుతుంది?

Question

Accepted Answer

**`context`** package అనేది **cancellation signals, deadlines, మరియు request-scoped values** లను API boundaries మరియు goroutines అంతటా రవాణా చేస్తుంది. ఇది operations యొక్క lifetime నిర్వహించడానికి — ప్రత్యేకించి work యొక్క cancellation మరియు timeouts లను function calls యొక్క chain ద్వారా ప్రచారం చేయడానికి ప్రామాణిక mechanism.

## ఇది పరిష్కరించే 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 చేస్తుంది, ఇది cancelled చేయబడవచ్చు; మీరు దాని resources లను free చేయడానికి తప్పనిసరిగా `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()` (cancellation పై close చేయబడే ఒక channel) ని check చేస్తాయి మరియు వెంటనే stop చేస్తాయి — ఇది cancellation వాస్తవానికి ఎలా ప్రచారం చేయబడుతుందో.

## Call chain ద్వారా context ను pass చేయడం (the 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 నుండి first parameter గా flow చేస్తుంది, కాబట్టి cancellation ప్రతి layer కు చేరుకుంటుంది (standard-library DB/HTTP calls సహా ఇవి ఒక context ను accept చేస్తాయి).

## 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` package అనేది robust, production-grade Go services ను రాయడానికి ప్రాథమికమైనది — ఇది goroutines మరియు API boundaries అంతటా **cancellation మరియు timeouts** నిర్వహించడానికి ప్రామాణిక, idiomatic way.

ఇది యొక్క primary value తరుగు పట్టిన work మరియు resource leaks నిరోధించడం: ఒక client disconnect చేసినప్పుడు, ఒక deadline pass చేసినప్పుడు, లేదా ఒక server shut down చేసినప్పుడు, context cancellation signal ను ప్రచారం చేస్తుంది కాబట్టి ఆ request కోసం spawned చేయబడిన అన్ని goroutines మరియు operations promptly stop చేస్తాయి rather than uselessly running (ఇది goroutine leaks కు వ్యతిరేక ఒక key defense).

ఇది real Go లో విస్తృతమైనది — HTTP servers, database calls, gRPC, మరియు చాలా networked libraries `context.Context` ని వాటి first parameter గా accept చేస్తాయి.

contexts సృష్టించడం (`WithTimeout`/`WithCancel`), cancellation కు respond చేయడం (`<-ctx.Done()`), must-call-`cancel()` rule, మరియు context ను call chains ద్వారా threading చేయడం యొక్క convention ను ఎలా understand చేయాలో ఇది ఏదైనా serious Go backend work మరియు ఒక common interview topic కు essential.