เมื่อใดที่คุณควรเลือก threading, multiprocessing หรือ asyncio?

Question

Accepted Answer

Python มีโมเดลการทำงานพร้อมกัน (concurrency) สามแบบ และการเลือกให้ถูกต้องขึ้นอยู่กับว่างานของคุณเป็น **I/O-bound** หรือ **CPU-bound** เป็นหลัก — การตัดสินใจที่ได้รับอิทธิพลอย่างมากจาก GIL (ซึ่งป้องกันไม่ให้ thread รันโค้ด Python แบบขนานกัน)

## โมเดลทั้งสามแบบ

```text
threading        → multiple threads, ONE process. GIL-limited for CPU.
multiprocessing  → multiple PROCESSES, each its own interpreter/GIL → true parallelism.
asyncio          → single thread, cooperative coroutines yielding at await points.
```

## threading — สำหรับการทำงานพร้อมกันแบบ I/O-bound

```python
from concurrent.futures import ThreadPoolExecutor

# ✅ good for I/O — the GIL is RELEASED during I/O waits, so waits overlap
with ThreadPoolExecutor(max_workers=10) as ex:
    results = list(ex.map(download_url, urls))   # many downloads concurrently
```

thread ทำงานได้ดีกับงานแบบ I/O-bound (network, file, DB) เพราะ GIL จะถูกปล่อยขณะรอ — การรอหลาย ๆ อย่างจึงดำเนินไปพร้อมกันได้ มัน**ไม่ได้**ช่วยเร่งความเร็วงานแบบ CPU-bound

## multiprocessing — สำหรับงานแบบขนานที่เป็น CPU-bound

```python
from concurrent.futures import ProcessPoolExecutor

# ✅ good for CPU — separate processes each have their own GIL → use all cores
with ProcessPoolExecutor(max_workers=4) as ex:
    results = list(ex.map(heavy_computation, data))   # genuine parallelism
```

สำหรับงานที่หนักด้าน CPU (image processing คณิตศาสตร์ การประมวลผลข้อมูล) process ที่แยกกันจะหลบเลี่ยง GIL เดี่ยวและรันแบบขนานได้จริงบนหลาย core ต้นทุนคือ: overhead ที่สูงกว่า (การ start process) และข้อมูลต้องถูก **serialize** ระหว่าง process (ไม่มี shared memory โดยปริยาย)

## asyncio — สำหรับ I/O ที่มีการทำงานพร้อมกันสูง

```python
import asyncio
# ✅ best for MANY concurrent I/O operations (thousands) — lightest weight
await asyncio.gather(*(fetch(url) for url in urls))
```

asyncio จัดการการดำเนินการ I/O พร้อมกันจำนวนมหาศาลบน thread เดียว ได้อย่างมีประสิทธิภาพมากกว่า thread (ไม่มี overhead ต่อ thread) — เหมาะอย่างยิ่งสำหรับ server และโค้ด network ที่มีการทำงานพร้อมกันสูง

## คู่มือการตัดสินใจ

```text
CPU-bound (computation)              → multiprocessing
I/O-bound, moderate concurrency      → threading (simple, works with sync libraries)
I/O-bound, HIGH concurrency          → asyncio (thousands of connections, but needs
                                       async-compatible libraries)
Mixed CPU + I/O                       → combine (e.g. asyncio + a process pool for CPU)
```

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

การเลือกโมเดล concurrency ที่ถูกต้องเป็นหนึ่งในการตัดสินใจด้านประสิทธิภาพของ Python ที่ส่งผลกระทบมากที่สุด และการเลือกผิด (ความผิดพลาดคลาสสิก: ใช้ thread กับงาน CPU-bound ซึ่ง GIL ทำให้ไร้ประโยชน์) นำไปสู่โค้ดที่ scale ไม่ได้

ตรรกะที่ชี้นำมาจาก GIL: **thread/asyncio สำหรับ I/O-bound** (GIL ถูกปล่อยขณะรอ — concurrency จึงได้ผล) และ **multiprocessing สำหรับ CPU-bound** (GIL แยกกันเพื่อ parallelism ที่แท้จริง) โดยนิยม asyncio เมื่อ concurrency สูงมาก

การเข้าใจจุดแข็งของแต่ละโมเดล ต้นทุน (overhead/serialization ของ process ข้อกำหนดด้านไลบรารีของ asyncio) และการตัดสินใจระหว่าง I/O กับ CPU เป็นสิ่งจำเป็นสำหรับการเขียน Python แบบ concurrent ที่ให้ประสิทธิภาพได้จริง