package context ใช้ทำอะไร?

Question

Accepted Answer

package **`context`** ส่งต่อ **สัญญาณการยกเลิก (cancellation), deadline และค่าที่ผูกกับ request (request-scoped values)** ข้ามขอบเขต API และ goroutine มันเป็นกลไกมาตรฐานสำหรับการควบคุมอายุ (lifetime) ของการดำเนินการ — โดยเฉพาะการยกเลิกงานและการแพร่กระจาย timeout ผ่านลูกโซ่ของการเรียกฟังก์ชัน

## ปัญหาหลักที่มันแก้

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

## การสร้าง 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` สร้าง context ลูกที่สามารถยกเลิกได้ คุณต้อง `defer cancel()` เพื่อปล่อยทรัพยากรของมัน

## การตอบสนองต่อการยกเลิก

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

ฟังก์ชันจะตรวจสอบ `ctx.Done()` (channel ที่ถูกปิดเมื่อมีการยกเลิก) และหยุดทันที — นี่คือวิธีที่การยกเลิกแพร่กระจายจริง ๆ

## การส่ง context ผ่านลูกโซ่ของการเรียก (ตามธรรมเนียม)

```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 ตัวแรก ดังนั้นการยกเลิกจึงไปถึงทุกชั้น (รวมถึงการเรียก DB/HTTP ของไลบรารีมาตรฐานที่รับ context)

## ค่าที่ผูกกับ request (ใช้อย่างประหยัด)

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

## ทำไมจึงสำคัญ

package `context` เป็นพื้นฐานของการเขียน Go service ที่แข็งแกร่งระดับ production — มันเป็นวิธีมาตรฐานที่เป็นสำนวนสำหรับการจัดการ **การยกเลิกและ timeout** ข้าม goroutine และขอบเขต API

คุณค่าหลักของมันคือการป้องกันงานที่สูญเปล่าและการรั่วไหลของทรัพยากร: เมื่อ client ตัดการเชื่อมต่อ, ครบกำหนดเวลา หรือเซิร์ฟเวอร์ปิดตัวลง context จะแพร่กระจายสัญญาณการยกเลิก เพื่อให้ goroutine และการดำเนินการทั้งหมดที่ถูกสร้างขึ้นสำหรับ request นั้นหยุดทันทีแทนที่จะทำงานต่อไปอย่างไร้ประโยชน์ (เป็นการป้องกันหลักต่อ goroutine leak)

มันพบได้ทั่วไปใน Go จริง — HTTP server, การเรียก database, gRPC และไลบรารีที่เชื่อมต่อเครือข่ายส่วนใหญ่รับ `context.Context` เป็น parameter ตัวแรก

การเข้าใจวิธีสร้าง context (`WithTimeout`/`WithCancel`), การตอบสนองต่อการยกเลิก (`<-ctx.Done()`), กฎที่ต้องเรียก `cancel()` และธรรมเนียมการร้อย context ผ่านลูกโซ่ของการเรียก เป็นสิ่งจำเป็นสำหรับงาน Go backend ที่จริงจังใด ๆ และเป็นหัวข้อสัมภาษณ์ที่พบบ่อย