Package context được dùng để làm gì?

Question

Accepted Answer

Package **`context`** mang theo **tín hiệu hủy (cancellation), thời hạn (deadline), và các giá trị theo phạm vi request** qua các ranh giới API và các goroutine. Đây là cơ chế chuẩn để kiểm soát vòng đời của các thao tác — đặc biệt để hủy công việc và truyền timeout qua một chuỗi các lời gọi hàm.

## Vấn đề cốt lõi nó giải quyết

```text
Một request khởi động công việc qua nhiều goroutine/hàm (truy vấn DB, gọi API, v.v.).
Nếu client ngắt kết nối hoặc một timeout xảy ra, bạn muốn HỦY toàn bộ công việc đó
để các goroutine không tiếp tục chạy vô ích (lãng phí tài nguyên / rò rỉ).
→ context truyền tín hiệu "dừng ngay" xuống toàn bộ chuỗi gọi.
```

## Tạo context

```go
ctx := context.Background()          // context gốc (đỉnh của cây)
ctx := context.TODO()                 // placeholder khi chưa chắc chắn

// với một timeout — tự động hủy sau khoảng thời gian
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // LUÔN gọi cancel để giải phóng tài nguyên

// với hủy thủ công
ctx, cancel := context.WithCancel(context.Background())
// gọi cancel() để báo hiệu hủy

// với một deadline (thời điểm cụ thể)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` dẫn xuất một context con có thể bị hủy; bạn phải `defer cancel()` để giải phóng tài nguyên của nó.

## Phản hồi với việc hủy

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // kích hoạt khi bị hủy hoặc hết thời gian
            return ctx.Err()           // trả về context.Canceled hoặc DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Các hàm kiểm tra `ctx.Done()` (một channel đóng khi bị hủy) và dừng kịp thời — đây là cách việc hủy thực sự lan truyền.

## Truyền context qua một chuỗi gọi (quy ước)

```go
// ctx theo quy ước là tham số ĐẦU TIÊN, đặt tên ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // truyền nó xuống — lời gọi DB tôn trọng việc hủy
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // các API thư viện chuẩn nhận context
}
```

Context chảy xuống call stack như tham số đầu tiên, nên việc hủy đến được mọi tầng (bao gồm các lời gọi DB/HTTP của thư viện chuẩn vốn nhận một context).

## Giá trị theo phạm vi request (dùng dè dặt)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // gắn một giá trị
id := ctx.Value(requestIDKey)                            // lấy nó ở phía sau
// ⚠️ cho metadata theo phạm vi request (request ID, auth) — KHÔNG để truyền tham số thường
```

## Tại sao điều này quan trọng

Package `context` là nền tảng để viết các dịch vụ Go vững chắc, cấp production — đó là cách chuẩn, idiomatic để xử lý **hủy và timeout** qua các goroutine và ranh giới API.

Giá trị chính của nó là ngăn công việc lãng phí và rò rỉ tài nguyên: khi một client ngắt kết nối, một deadline trôi qua, hoặc một server shutdown, context truyền tín hiệu hủy để tất cả các goroutine và thao tác sinh ra cho request đó dừng kịp thời thay vì chạy vô ích (một phòng tuyến then chốt chống rò rỉ goroutine).

Nó phổ biến trong Go thực tế — các HTTP server, lời gọi database, gRPC, và hầu hết các thư viện mạng nhận một `context.Context` làm tham số đầu tiên của chúng.

Hiểu cách tạo context (`WithTimeout`/`WithCancel`), phản hồi với việc hủy (`<-ctx.Done()`), quy tắc phải-gọi-`cancel()`, và quy ước luồn context qua các chuỗi gọi là thiết yếu cho bất kỳ công việc backend Go nghiêm túc nào và là một chủ đề phỏng vấn phổ biến.