Paket `context` digunakan untuk apa?

Question

Accepted Answer

Paket **`context`** membawa **sinyal pembatalan, deadline, dan nilai yang spesifik untuk permintaan** lintas batas API dan goroutine. Ini adalah mekanisme standar untuk mengontrol masa hidup operasi — terutama untuk membatalkan pekerjaan dan menyebarkan timeout melalui rangkaian panggilan fungsi.

## Masalah inti yang diselesaikannya

```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.
```

## Membuat context

```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` menurunkan context anak yang dapat dibatalkan; Anda harus `defer cancel()` untuk membebaskan sumber dayanya.

## Merespons pembatalan

```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)
        }
    }
}
```

Fungsi memeriksa `ctx.Done()` (sebuah channel yang ditutup saat pembatalan) dan berhenti dengan cepat — ini adalah cara pembatalan benar-benar menyebar.

## Melewatkan context melalui rantai panggilan (konvensi)

```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 mengalir ke bawah call stack sebagai parameter pertama, sehingga pembatalan mencapai setiap lapisan (termasuk panggilan DB/HTTP pustaka standar yang menerima context).

## Nilai yang spesifik untuk permintaan (gunakan dengan hemat)

```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
```

## Mengapa ini penting

Paket `context` sangat fundamental untuk menulis layanan Go yang robust dan production-grade — ini adalah cara standar dan idiomatik untuk menangani **pembatalan dan timeout** lintas goroutine dan batas API.

Nilai utamanya adalah mencegah pekerjaan yang terbuang sia-sia dan kebocoran sumber daya: ketika klien terputus, deadline berlalu, atau server dimatikan, context menyebarkan sinyal pembatalan sehingga semua goroutine dan operasi yang spawn untuk permintaan tersebut berhenti dengan cepat daripada berjalan tanpa berguna (pertahanan kunci terhadap kebocoran goroutine).

Ini tersebar luas di Go nyata — server HTTP, panggilan database, gRPC, dan sebagian besar pustaka jaringan menerima `context.Context` sebagai parameter pertama mereka.

Memahami cara membuat context (`WithTimeout`/`WithCancel`), merespons pembatalan (`<-ctx.Done()`), aturan must-call-`cancel()`, dan konvensi threading context melalui rantai panggilan adalah hal penting untuk pekerjaan backend Go yang serius dan topik wawancara yang umum.