ਤੁਸ਼ੀਂ threading, multiprocessing, ਜਾਂ asyncio ਕਦੋਂ ਚੁਣਦੇ ਹੋ?

Question

Accepted Answer

Python ਤਿੰਨ concurrency models ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਹੀ ਚੋਣ ਮੁੱਖ ਤੌਰ 'ਤੇ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਤੁਹਾਡਾ ਕੰਮ **I/O-bound** ਹੈ ਜਾਂ **CPU-bound** — ਇਹ ਫੈਸਲਾ GIL (ਜੋ threads ਨੂੰ Python ਕੋਡ ਨੂੰ ਸਮਾਨਤਾ ਨਾਲ ਚਲਾਉਣ ਤੋਂ ਰੋਕਦਾ ਹੈ) ਦੁਆਰਾ ਬਹੁਤ ਪ੍ਰਭਾਵਿਤ ਹੁੰਦਾ ਹੈ।

## ਤਿੰਨ 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 ਕਾਮਾਂ (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-heavy ਕੰਮ (image processing, math, data crunching) ਲਈ, ਵੱਖ-ਵੱਖ processes ਸਿੰਗਲ GIL ਨੂੰ bypass ਕਰਦੇ ਹਨ ਅਤੇ ਮਲਟੀਪਲ cores 'ਤੇ ਸੱਚੀ ਸਮਾਨਤਾ ਵਿੱਚ ਚਲਦੇ ਹਨ। ਲਾਗਤ: ਉੱਚੀ ਓਵਰਹੈੱਡ (process startup) ਅਤੇ ਡੇਟਾ processes ਦੇ ਵਿੱਚ **ਸਰੀਅਲਾਈਜ਼** ਹੋ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਡਿਫ਼ਲਟ ਨਾਲ shared memory ਨਹੀਂ)।

## asyncio — high-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 'ਤੇ ਬਹੁਤ ਸਾਰੀਆਂ I/O operations ਨੂੰ ਇੱਕਲ਼ੌਤੀ ਤੌਰ 'ਤੇ ਹੈਂਡਲ ਕਰਦਾ ਹੈ, threads ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ ਨਾਲ (ਕੋਈ per-thread overhead ਨਹੀਂ) — servers ਅਤੇ high-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 ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਫੈਸਲਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਗ਼ਲਤ ਕਰਨਾ (ਕਲਾਸਿਕ ਗ਼ਲਤੀ: CPU-bound ਕੰਮ ਲਈ threads, ਜਿਸ ਨੂੰ GIL ਬੇਕਾਰ ਬਣਾ ਦਿੰਦੀ ਹੈ) ਉਸ ਕੋਡ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ ਜੋ ਸਕੇਲ ਨਹੀਂ ਹੁੰਦਾ।

ਨਿਰਦੇਸ਼ਾਤਮਕ ਤਰਕ GIL ਤੋਂ ਵਹਿੰਦਾ ਹੈ: **I/O-bound ਲਈ threads/asyncio** (GIL waits ਦੌਰਾਨ ਰਿਲੀਜ਼ ਹੋ ਜਾਂਦੀ ਹੈ — concurrency ਕੰਮ ਕਰਦੀ ਹੈ) ਅਤੇ **CPU-bound ਲਈ multiprocessing** (ਸੱਚੀ parallelism ਲਈ ਵੱਖ GILs), asyncio ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾ ਰਹੀ ਹੈ ਜਦੋਂ concurrency ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੋ।

ਹਰੇਕ model ਦੀਆਂ ਤਾਕਤਾਂ, ਖਰਚਿਆਂ (process overhead/serialization, asyncio ਦੀਆਂ library requirements), ਅਤੇ I/O-vs-CPU ਫੈਸਲੇ ਨੂੰ ਸਮਝਣਾ ਲਾਜ਼ਮੀ ਹੈ concurrent Python ਲਿਖਣ ਲਈ ਜੋ ਅਸਲ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਨ ਨਿਭਾਉਂਦਾ ਹੈ।