การทำงานพร้อมกัน — ภาพรวม

JavaScript ทำงานแบบ single-threaded — Go ทำงานแบบ multi-threaded จริง ๆ

ในฐานะนักพัฒนา TypeScript/Node.js คุณใช้ชีวิตอยู่กับ event loop โค้ด JS ทั้งหมดรันบน thread เดียว และ “concurrency” ที่คุณเห็นคือการสลับ context ไปมาระหว่าง callbacks, Promises และ async/await — ไม่ใช่ parallelism จริง

Go ต่างออกไปโดยสิ้นเชิง Go runtime จะ schedule goroutines ลงบน OS threads จริงหลายตัว goroutine หลายตัวจึงรันพร้อมกันได้จริงบน CPU คนละ core โดยไม่ต้องพึ่ง Worker Threads

Concurrency ≠ Parallelism

Rob Pike (หนึ่งในผู้สร้าง Go) อธิบายไว้ได้ชัดเจนว่า:

Concurrency คือการจัดการหลายสิ่งพร้อมกัน — เป็นเรื่องของโครงสร้าง
Parallelism คือการทำหลายสิ่งพร้อมกันจริง — เป็นเรื่องของการรัน

เชฟที่สับผักไปตอนที่น้ำกำลังเดือด = concurrent (จัดการหลายอย่างพร้อมกัน) ส่วนเชฟสองคนทำงานเคียงข้างกันในครัวเดียว = parallel (ทำหลายอย่างพร้อมกันจริง)

Node.js เก่งเรื่อง concurrency (non-blocking I/O) แต่ทำ parallelism จริงไม่ได้ถ้าไม่ใช้ Worker Threads หรือแยกหลาย process ส่วน Go รองรับทั้งสองอย่างได้ในตัว

โมเดล concurrency เปรียบเทียบ

// JavaScript: single-threaded event loop
// "concurrency" through callbacks / Promises
async function fetchData(url: string) {
  const res = await fetch(url);   // yields to event loop
  return res.json();
}

// setTimeout / setInterval schedule callbacks on the loop
setTimeout(() => console.log("later"), 0);
console.log("first"); // always prints before "later"

// Go: real concurrent goroutines
// Each 'go' spawns a lightweight thread managed by Go runtime
package main

import (
    "fmt"
    "sync"
)

func fetchData(url string, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println("Fetching:", url) // runs concurrently
}

func main() {
    var wg sync.WaitGroup
    urls := []string{"api/users", "api/orders", "api/products"}
    for _, url := range urls {
        wg.Add(1)
        go fetchData(url, &wg)
    }
    wg.Wait() // block until all goroutines finish
}

สิ่งที่จะเรียนในโมดูลนี้

Goroutines — go f() สร้าง goroutine ได้ทันที; เปรียบเทียบกับ async functions
Channels — ท่อส่งข้อมูลระหว่าง goroutines; เปรียบเทียบกับ Promises/callbacks
Select — เลือกจากหลาย channels พร้อมกัน; เปรียบเทียบกับ Promise.race
Sync — WaitGroup, Mutex, RWMutex สำหรับ shared state
Context — cancellation และ deadlines; เปรียบเทียบกับ AbortController
Worker Pools — pattern สำหรับจัดการงานพร้อมกันอย่างมีประสิทธิภาพ

🟦 ทำไม Go ถึง Concurrent โดยธรรมชาติ

Go ออกแบบมารองรับ concurrency ตั้งแต่วันแรก บนหลักการ CSP (Communicating Sequential Processes) ของ Tony Hoare หลักคิดที่ Go team ยึดถือคือ:

“Don’t communicate by sharing memory; share memory by communicating.”

หมายความว่าแทนที่จะใช้ lock ปกป้อง shared data ให้ส่งข้อมูลระหว่าง goroutines ผ่าน channels แทน — channel เป็นทั้งช่องทางสื่อสารและกลไก synchronization ในตัว

Goroutines เบามาก — stack เริ่มต้นแค่ 2KB แล้วขยายเองตามต้องการ (เทียบกับ OS thread ที่ ~1MB) โปรแกรม Go เดียวจึงรัน goroutine ได้หลักแสนตัวพร้อมกัน

Open in Playground

package main

import (
  "fmt"
  "sync"
)

func task(name string, wg *sync.WaitGroup) {
  defer wg.Done()
  fmt.Printf("Task %s running\n", name)
}

func main() {
  var wg sync.WaitGroup
  tasks := []string{"A", "B", "C"}
  for _, t := range tasks {
    wg.Add(1)
    go task(t, &wg)
  }
  wg.Wait()
  fmt.Println("All tasks complete")
}