threading, multiprocessing, அல்லது asyncio-ஐ எப்போது தேர்வு செய்வீர்கள்?

Question

Accepted Answer

Python மூன்று concurrency models-ஐ வழங்குகிறது, மேலும் சரியாகத் தேர்வு செய்வது முக்கியமாக உங்கள் வேலை **I/O-bound** அல்லது **CPU-bound** என்பதைப் பொறுத்தது — இது GIL-ஆல் (இது threads-ஐ Python code-ஐ இணையாக இயக்க விடாமல் தடுக்கிறது) பெரிதும் வடிவமைக்கப்பட்ட ஒரு முடிவு.

## மூன்று models

```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 concurrency-க்கு

```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
```

Threads I/O-bound tasks-க்கு (network, files, DB) நன்றாக வேலை செய்கின்றன, ஏனெனில் காத்திருக்கும்போது GIL விடுவிக்கப்படுகிறது — பல காத்திருப்புகள் ஒரே நேரத்தில் தொடர்கின்றன. அவை CPU-bound வேலையை வேகப்படுத்த **இல்லை**.

## multiprocessing — CPU-bound parallelism-க்கு

```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, math, data crunching), தனித்தனி processes ஒற்றை GIL-ஐ கடந்து பல cores-இல் உண்மையில் இணையாக இயங்குகின்றன. செலவு: அதிக overhead (process startup) மற்றும் data processes-க்கு இடையே **serialize** செய்யப்பட வேண்டும் (இயல்பாக shared memory இல்லை).

## asyncio — அதிக-concurrency 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 ஒரு thread-இல் பெரும் எண்ணிக்கையிலான concurrent I/O operations-ஐ கையாளுகிறது, threads-ஐ விட திறமையாக (per-thread overhead இல்லை) — servers மற்றும் அதிக-concurrency network code-க்கு ஏற்றது.

## முடிவெடுக்கும் வழிகாட்டி

```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 model-ஐ தேர்வு செய்வது மிகவும் முக்கியமான Python performance முடிவுகளில் ஒன்று, அதைத் தவறாகச் செய்வது (செம்மொழித் தவறு: CPU-bound வேலைக்கு threads, இதை GIL பயனற்றதாக ஆக்குகிறது) scale ஆகாத code-க்கு வழிவகுக்கிறது.

வழிகாட்டும் தர்க்கம் GIL-இலிருந்து பாய்கிறது: **I/O-bound-க்கு threads/asyncio** (காத்திருப்புகளின்போது GIL விடுவிக்கப்படுகிறது — concurrency வேலை செய்கிறது) மற்றும் **CPU-bound-க்கு multiprocessing** (உண்மையான parallelism-க்கு தனித்தனி GILs), concurrency மிக அதிகமாக இருக்கும்போது asyncio விரும்பப்படுகிறது.

ஒவ்வொரு model-இன் பலங்கள், செலவுகள் (process overhead/serialization, asyncio-வின் library தேவைகள்), மற்றும் I/O-vs-CPU முடிவை புரிந்துகொள்வது உண்மையில் performance-ஐ வழங்கும் concurrent Python எழுதுவதற்கு இன்றியமையாதது.