Go Day 6 — Cheat Sheet

สารบัญ

1. Generics — type parameter & constraint
2. Generic struct & เมื่อไหร่ไม่ควรใช้
3. Goroutine & WaitGroup
4. Channel
5. select
6. Mutex & Race Detector
7. Context & Graceful Shutdown
8. Worker Pool & GOMAXPROCS
9. Project Layout
10. GORM
11. อ่าน error ของ concurrency
12. ตารางกับดักรวม

1 · Generics — type parameter & constraint

func Sum[T Number](values []T) T { ... }
//       └── type parameter ── ┘  └ ค่า ┘  └ return

// [] เหลี่ยม = ส่ง type   ·   () กลม = ส่งค่า

เครื่องหมาย ~

type Integer interface {  int | int64 }   // รับเฉพาะ int เป๊ะ ๆ
type Integer interface { ~int | ~int64 }   // รับทุก type ที่ underlying เป็น int

type Score int
Max(Score(80), Score(95))
// ไม่มี ~ → Score does not satisfy Integer (possibly missing ~ for int in Integer)

เขียน constraint เอง → ใส่ ~ ไว้ก่อนเกือบทุกครั้ง

สำนวนที่ต้องจำ

func Pop[T any]() (T, bool) {
    var zero T          // ← ทางเดียวที่ได้ zero value ของ T
    return zero, false   // return nil / return 0 / return T{} ใช้ไม่ได้
}

2 · Generic struct & เมื่อไหร่ไม่ควรใช้

type Stack[T any] struct { items []T }

func (s *Stack[T]) Push(v T) { ... }   // receiver ต้องมี [T]

numbers := Stack[int]{}                // ต้องระบุ type เสมอ

อย่ารีบทำทุกอย่างเป็น generic — วันไหนมี type ที่สองค่อยแปลง

3 · Goroutine & WaitGroup

go doSomething()    // สั่งแล้วไปต่อทันที ไม่รอ

main จบ = โปรแกรมจบทันที · runtime ไม่รอ goroutine ที่ค้างอยู่เลย

var wg sync.WaitGroup

wg.Add(1)              // ← ต้องอยู่ก่อน go เสมอ
go func() {
    defer wg.Done()      // ← บรรทัดแรกเสมอ
    work()
}()
wg.Wait()

// Go 1.25+ — จับคู่ Add/Done/go ให้ในคำสั่งเดียว
wg.Go(func() { work() })
wg.Wait()

4 · Channel

ch := make(chan int)        // unbuffered — ความจุ 0
ch := make(chan int, 3)     // buffered
var ch chan int              // nil — ใช้ไม่ได้ ต้อง make

ch <- 10                    // ส่ง
v := <-ch                    // รับ
v, ok := <-ch                // รับ + เช็คว่าปิดหรือยัง
close(ch)

เมื่อ channel ถูกปิดแล้ว

คนส่งเป็นคนปิด ไม่ใช่คนรับ · มีคนส่งหลายคน → ให้ตัวที่รอทุกคนเสร็จเป็นคนปิด · ไม่ปิดเลยก็ได้ถ้าไม่มีใคร range (ไม่ใช่ memory leak)

Directional channel

func producer(ch chan<- int)   // ส่งอย่างเดียว — ลูกศรหลัง chan
func consumer(ch <-chan int)   // รับอย่างเดียว — ลูกศรหน้า chan

// consumer สั่ง close ไม่ได้:
// cannot close receive-only channel ch (variable of type <-chan int)

5 · select

select {
case msg := <-messages:      // รับ
case ch <- value:            // ส่ง — ใส่ได้เหมือนกัน
case <-time.After(2*time.Second):   // timeout
case <-ctx.Done():          // ยกเลิก
default:                    // ไม่มีใครพร้อม → ทำทันที ไม่รอ
}

⚠️ default ใน for เปล่า ๆ = busy loop (วัดได้ 95.7 ล้านรอบใน 0.3 วิ · กิน CPU เต็ม core) — เอา default ออกให้ select block แทน

// ✅ default ที่ใช้ถูก — มีอย่างอื่นให้ทำจริง
select {
case metrics <- stat:
default:
    droppedCount++      // buffer เต็ม ยอมทิ้ง
}

6 · Mutex & Race Detector

var mu sync.Mutex

mu.Lock()
defer mu.Unlock()      // ← บรรทัดถัดไปเสมอ
counter++

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

func (c *Cache) Get(k string) (string, bool) {
    c.mu.RLock(); defer c.mu.RUnlock()   // อ่าน — หลายคนพร้อมกันได้
    v, ok := c.data[k]; return v, ok
}

func (c *Cache) Set(k, v string) {
    c.mu.Lock(); defer c.mu.Unlock()     // เขียน — คนเดียว
    c.data[k] = v
}

วัดจริง — 2000 goroutine อ่านพร้อมกัน: Mutex 12.4ms · RWMutex 0.8ms → เร็วขึ้น ~16 เท่า

Race Detector

go run   -race main.go
go test  -race ./...
go build -race

// เจอ race →  WARNING: DATA RACE (บอกบรรทัดที่อ่าน/เขียน/สร้าง goroutine)
//             Found N data race(s)
//             exit status 66   ← CI แดงเองอัตโนมัติ

ฟ้อง = มีจริง 100% · ไม่ฟ้อง ≠ ไม่มี (ตรวจเฉพาะเส้นทางที่รันจริง)

เก้ากฎความปลอดภัย

1. ไม่ share ก็ไม่ต้อง lock
2. ของกลางต้องมีเจ้าของ — ใครเขียนได้ · ใครอ่านได้ · sync ด้วยอะไร
3. Lock ให้แคบ แต่ครบ — อย่าครอบ network/DB call
4. อย่า copy Mutex/RWMutex/WaitGroup หลังเริ่มใช้
5. defer Unlock() เสมอ
6. ทุก goroutine ต้องตอบได้ว่าจะจบเมื่อไหร่
7. คิดเรื่องยกเลิกตั้งแต่ออกแบบ
8. รัน race detector เป็นนิสัย
9. "ทำ concurrent ได้" ≠ "ควรทำ"

7 · Context & Graceful Shutdown

ctx, cancel := context.WithCancel(context.Background())
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()      // ← ทุกครั้ง ไม่มีข้อยกเว้น

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            doChunkOfWork()
        }
    }
}

ใช้ errors.Is ไม่ใช่ == · ctx เป็น parameter ตัวแรก เสมอ · ห้ามเก็บใน struct · ห้ามส่ง nil (ใช้ context.TODO())

⚠️ cancel() ไม่หยุด goroutine — แค่ปิด channel ตัวที่ไม่เช็ค ctx.Done() จะทำงานต่อไปเรื่อย ๆ
context = บอกให้หยุด · WaitGroup = รอจนหยุดจริง — ต้องมีคู่กัน

context ซ้อนกัน → ตัวที่หมดก่อนชนะ · child ขยายเวลาเกิน parent ไม่ได้

Graceful Shutdown

ctx, stop := signal.NotifyContext(
    context.Background(), os.Interrupt, syscall.SIGTERM,
)
defer stop()

<-ctx.Done()                 // ค้างจนได้สัญญาณ → ctx.Err() = context canceled
srv.Shutdown(shutdownCtx)   // เก็บงานค้างให้จบ

8 · Worker Pool & GOMAXPROCS

func worker(id int, jobs <-chan Job, results chan<- Result, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs { results <- process(job) }
}

for w := 1; w <= numWorkers; w++ { wg.Add(1); go worker(w, jobs, results, &wg) }
for _, j := range allJobs { jobs <- j }
close(jobs)

go func() { wg.Wait(); close(results) }()   // ← ต้องอยู่ใน goroutine!

for r := range results { ... }

คนที่ รอ กับคนที่ รับ ต้องไม่ใช่ goroutine เดียวกัน — ไม่งั้น deadlock! [sync.WaitGroup.Wait]

วัดจริง 60 งาน บนเครื่อง GOMAXPROCS = 10:

งาน CPU ตันที่ GOMAXPROCS · งาน I/O ดีขึ้นเรื่อย ๆ จนกว่า worker จะเท่าจำนวนงาน
⚠️ ใน container: Go ก่อน 1.25 เห็น core ของเครื่องแม่ ไม่ใช่ CPU limit

9 · Project Layout

myapp/
├── cmd/api/main.go              ← จุดเริ่ม ประกอบทุกอย่าง (มีได้หลายตัว)
├── internal/
│   ├── user/                    ← จัดตามโดเมน ไม่ใช่ตามชนิดไฟล์
│   │   ├── handler.go           HTTP ↔ JSON · ไม่รู้จัก database
│   │   ├── service.go           กฎธุรกิจ · ไม่รู้จัก HTTP
│   │   ├── repository.go        SQL อย่างเดียว
│   │   ├── model.go             struct ที่ตรงกับตาราง
│   │   └── dto.go               struct request/response (มี json tag)
│   └── platform/database/       ← ของกลางที่ทุกโดเมนใช้
├── go.mod
└── go.sum

internal/ — module อื่น import ไม่ได้จริง: use of internal package ... not allowed
แยก dto.go จาก model.go เพื่อไม่ให้ PasswordHash หลุดโดยลืมใส่ json:"-"
ลูกศรชี้ทางเดียว: handler → service → repository · ctx เดินทางไปด้วยทุกชั้น

10 · GORM

go get -u gorm.io/gorm
go get -u gorm.io/driver/postgres
go mod tidy        ← ลืมแล้วจะเจอ missing go.sum entry

type User struct {
    ID    uint   `gorm:"primaryKey"`
    Name  string
    Email string `gorm:"unique"`
}
// User → ตาราง "users"  ·  OrderItem → ตาราง "order_items"

db.Create(&user)                                   // เขียน ID กลับเข้า struct (ต้องมี &)
db.First(&user, 1)                                // หา id = 1
db.Find(&users)                                    // ทั้งหมด
db.Where("name = ?", name).Find(&users)          // ใช้ ? เสมอ — กัน SQL injection
db.Model(&user).Update("Name", "Somsri")
db.Delete(&user, 1)
db.WithContext(ctx).Find(&users)                  // ส่ง ctx ต่อถึง database

⚠️ GORM คืน *gorm.DB ไม่ใช่ (value, error) — ต้องเช็ค .Error เอง compiler ไม่บังคับ

Transaction

db.Transaction(func(tx *gorm.DB) error {
    tx.Model(...).Update("balance", gorm.Expr("balance - ?", 50))
    return nil      // nil = commit  ·  error = rollback
})

ใช้ tx ข้างใน ไม่ใช่ db — เผลอใช้ db = คำสั่งนั้นอยู่นอก transaction

11 · อ่าน error ของ concurrency

เวลาเจอ fatal error: all goroutines are asleep - deadlock! ให้ดูคำในวงเล็บเหลี่ยมของบรรทัด goroutine N [...] เป็นอันดับแรก

sync.Mutex ของ Go ไม่ reentrant — method ที่ถือ lock อยู่แล้วเรียก method อื่นที่ขอ lock เดิม = ค้างตลอดกาล
ทางแก้: แยก method ที่ไม่ล็อก ออกมาเป็นตัว unexported

คำสั่งที่ควรรันก่อน commit ทุกครั้ง

go vet ./...        // จับ copy lock · lostcancel · misuse ต่าง ๆ
go test -race ./... // จับ data race

12 · ตารางกับดักรวม

อ้างอิง

• When To Use Generics — Ian Lance Taylor
• Go Concurrency Patterns: Pipelines and cancellation
• Go Concurrency Patterns: Context
• Data Race Detector
• Organizing a Go module
• GORM Guides