อธิบาย lock, mutex, critical section และ semaphore

Question

IT Interview Practice · Accepted Answer

**Mutex คือ lock ที่รับประกัน mutual exclusion — มีเพียง thread เดียวเท่านั้นที่ถือมันและเข้าสู่ critical section ที่ถูกป้องกันได้ในแต่ละครั้ง** Semaphore ขยายแนวคิดนี้ให้อนุญาตผู้ถือพร้อมกันได้ถึง N ราย

## มันทำงานอย่างไร

- **Critical section**: ส่วนของโค้ดที่แตะ state ที่แชร์และต้องไม่ทำงานพร้อมกัน
- **Mutex (mutual exclusion)**: จับก่อนเข้าส่วนนั้น ปล่อยหลังจากออก thread ที่สองจะบล็อกจนกว่าจะว่าง โดยทั่วไปเป็นของ thread ที่จับมัน (มีเพียงมันเท่านั้นที่ปล่อยได้)
- **Semaphore**: ถือตัวนับ permit จำนวน N ตัว `acquire()` ลดค่า (บล็อกเมื่อถึง 0), `release()` เพิ่มค่า Mutex ก็คือ semaphore ที่ N=1 แต่มี semantics ของการเป็นเจ้าของ

```python
lock = threading.Lock()
def transfer(a, b, amt):
    with lock:                 # critical section — one thread at a time
        a.balance -= amt
        b.balance += amt

# Semaphore: cap concurrent DB connections at 10
sem = threading.Semaphore(10)
def query():
    with sem:                  # up to 10 threads run this concurrently
        db.execute(...)
```

## ข้อผิดพลาดที่พบบ่อย

- **ลืมปล่อย (release)** → บล็อกถาวร ใช้ `with`/RAII/`defer` เพื่อให้ปล่อยอัตโนมัติแม้เกิด exception
- **ถือ lock นานเกินไป** ทำลาย throughput; ให้ critical section เล็ก
- **Lock granularity**: lock หยาบตัวเดียวนั้นง่ายแต่ทำให้ทุกอย่างเป็นอนุกรม; lock ละเอียดหลายตัวขยายได้ดีกว่าแต่เสี่ยง deadlock

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

สิ่งเหล่านี้เป็นเครื่องมือพื้นฐานสำหรับปกป้อง state ที่แชร์ Mutex ทำให้การเข้าถึงเป็นอนุกรมเพื่อป้องกัน race; semaphore จำกัดปริมาณของ resource pool (connection, permit, rate limit) การเลือก primitive ที่ถูกต้องและรักษา critical section ให้สั้นคือความต่างระหว่าง ถูกต้องและเร็ว กับ ถูกต้องแต่ช้า

มันทำงานอย่างไร

ข้อผิดพลาดที่พบบ่อย

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

คำถามที่เกี่ยวข้อง