तपाईंले threading, multiprocessing वा asyncio कहिले छनोट गर्नुहुन्छ?

Question

Accepted Answer

Python ले तीनवटा concurrency मडेलहरू प्रदान गर्छ, र सही विकल्प मुख्यतः यस बात मा निर्भर गर्छ कि तपाईंको काम **I/O-bound** हो वा **CPU-bound** — GIL द्वारा भारी रूपमा आकार दिइएको निर्णय (जो थ्रेडहरूलाई 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 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
```

थ्रेडहरू I/O-bound कार्यहरूको लागि राम्रोसँग काम गर्छन् (नेटवर्क, फाइलहरू, डीबी) किनभने 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-गहन कामको लागि (छवि प्रसंस्करण, गणित, डेटा क्रन्चिङ), अलग प्रक्रियाहरू एकल GIL लाई बाइपास गर्छन् र वास्तवमा बहु कोरहरूमा समानान्तरमा चल्छन्। लागत: उच्च ओभरहेड (प्रक्रिया स्टार्टअप) र डेटा प्रक्रियाहरू बीच **serialized** हुनु पर्छ (पूर्वनिर्धारित रूपमा कोई साझा मेमोरी छैन)।

## 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 एक थ्रेडमा ठूलो संख्यामा concurrent I/O अपरेशनहरू ह्यान्डल गर्छ, थ्रेडहरूभन्दा अधिक कुशलतापूर्वक (कोई प्रति-थ्रेड ओभरहेड छैन) — सर्भर र उच्च-concurrency नेटवर्क कोडको लागि आदर्श।

## निर्णय गाइड

```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 कार्यक्षमताको सबैभन्दा महत्वपूर्ण निर्णयहरू मध्ये एक हो, र यो गलत गर्नु (क्लासिक त्रुटि: CPU-bound कामको लागि थ्रेडहरू, जुन GIL लाई बेकार बनाउँछ) कोडमा परिणत हुन्छ जो स्केल हुँदैन।

मार्गदर्शन तर्क GIL बाट प्रवाह हुन्छ: **I/O-bound को लागि थ्रेड/asyncio** (GIL प्रतीक्षा गरीरहेको बेला रिलिज हुन्छ — concurrency कार्य गर्छ) र **CPU-bound को लागि multiprocessing** (वास्तविक parallelism को लागि अलग GILs), asyncio लाई जब concurrency धेरै उच्च हुन्छ तब प्राथमिकता दिइन्छ।

प्रत्येक मडेलको शक्तिहरू, लागतहरू (प्रक्रिया ओभरहेड/serialization, asyncio को पुस्तकालय आवश्यकताहरू), र I/O-vs-CPU निर्णय बुझ्नु concurrent Python लेख्न आवश्यक छ जो वास्तवमा कार्यक्षमता प्रदान गर्छ।