goroutine คืออะไร?

Question

goroutine คืออะไร?

Accepted Answer

**goroutine** คือฟังก์ชันที่ทำงานพร้อมกัน (concurrent) แบบน้ำหนักเบาที่จัดการโดย runtime ของ Go การเริ่ม goroutine ทำได้ง่ายเพียงใส่ `go` ไว้หน้าการเรียกฟังก์ชัน goroutine เป็นคุณสมบัติด้าน concurrency ที่เป็นเอกลักษณ์ของ Go — ราคาถูกกว่า OS thread มาก ดังนั้นคุณสามารถรันได้เป็นพันหรือเป็นล้าน

## การเริ่ม goroutine

```go
func sayHello() {
    fmt.Println("Hello from a goroutine")
}

go sayHello()        // launch concurrently — main does NOT wait for it
go func() {           // or an anonymous function
    fmt.Println("inline goroutine")
}()
```

คีย์เวิร์ด `go` เริ่มฟังก์ชันบน goroutine ใหม่และคืนค่าทันที — โค้ดที่เรียกจะทำงานต่อโดยไม่รอ

## ทำไม goroutine จึงพิเศษ: มันราคาถูก

```text
OS thread:  ~1–2 MB of memory each → thousands max
Goroutine:  ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
```

goroutine ไม่ใช่ OS thread — scheduler ของ Go จัดสรร (multiplex) goroutine จำนวนมากลงบน OS thread เพียงไม่กี่ตัว สิ่งนี้ทำให้มันราคาถูกเป็นพิเศษ เปิดทาง concurrency มหาศาล (เช่น หนึ่ง goroutine ต่อหนึ่ง connection ในเซิร์ฟเวอร์ที่จัดการ connection นับล้าน)

## ปัญหาการ synchronize: main อาจออกเร็วเกินไป

```go
func main() {
    go sayHello()    // ❌ main might EXIT before this goroutine runs → nothing printed
    // program ends immediately
}
```

เมื่อ `main` คืนค่า โปรแกรมจะจบ — ทำลาย goroutine ที่ยังทำงานอยู่ทุกตัว คุณจึงต้องประสานงานกัน

## การรอด้วย sync.WaitGroup

```go
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)                    // increment the counter
    go func(n int) {
        defer wg.Done()          // decrement when this goroutine finishes
        fmt.Println("worker", n)
    }(i)                          // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait()                         // BLOCK until all goroutines call Done()
```

`sync.WaitGroup` เป็นวิธีมาตรฐานในการรอให้ goroutine ชุดหนึ่งทำงานเสร็จ

## การสื่อสารด้วย channel

```go
ch := make(chan string)
go func() { ch <- "result" }()   // send a result on the channel
msg := <-ch                       // receive (blocks until a value arrives)
```

ปรัชญาของ Go: **"Don't communicate by sharing memory; share memory by communicating"** — ใช้ channel ในการส่งข้อมูลระหว่าง goroutine แทนการใช้ตัวแปรร่วม + lock

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

goroutine เป็นคุณสมบัติที่นิยามตัวตนของ Go และเป็นเหตุผลหลักที่ทำให้มันโดดเด่นในระบบที่ทำงานพร้อมกันและเชื่อมต่อเครือข่าย

ความเบาสุดขีดของมัน (กิโลไบต์เทียบกับเมกะไบต์ของ thread, จัดสรรแบบ M:N ลงบน OS thread) ทำให้ concurrency มหาศาลเป็นเรื่องที่ใช้งานได้จริงและง่าย — เซิร์ฟเวอร์สามารถสร้าง goroutine ต่อหนึ่ง request หรือ connection ได้โดยไม่ต้องกังวลเรื่องทรัพยากร ซึ่งทำได้ยากหรือเป็นไปไม่ได้กับ OS thread

การเข้าใจวิธีเริ่มมัน (`go`), ความจำเป็นอย่างยิ่งในการ **synchronize** (การที่ main ออกจะทำลาย goroutine; ใช้ `WaitGroup` เพื่อรอ) และความนิยมของ Go ในการ **สื่อสารผ่าน channel** มากกว่าหน่วยความจำร่วม เป็นพื้นฐานของการเขียน Go แบบ concurrent ที่ถูกต้อง

goroutine (และรูปแบบรอบ ๆ มัน) เป็นหัวใจของคุณค่าที่ Go นำเสนอ และเป็นหนึ่งในหัวข้อที่สำคัญและถูกถามบ่อยที่สุดในภาษานี้