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

Question

IT Interview Practice · 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.

ఇది పరిష్కరించే core problem

Contexts సృష్టించడం

Cancellation కు రెస్పాన్స్ ఇవ్వడం

Call chain ద్వారా context ను pass చేయడం (the convention)

Request-scoped values (sparingly ఉపయోగించండి)

ఇది ఎందుకు ముఖ్యమైనది

సంబంధిత ప్రశ్నలు