GIL क्या है और यह समवर्तिता को कैसे प्रभावित करता है?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) CPython (मानक Python कार्यान्वयन) में एक mutex है जो केवल **एक थ्रेड को एक बार में Python bytecode को निष्पादित करने की अनुमति देता है**। इसका अर्थ है कि Python थ्रेड्स कई CPU कोर पर Python कोड को सच में समानांतर रूप से नहीं चला सकते — समवर्तिता के लिए एक प्रमुख विचार।

## व्यावहारिक रूप से GIL का अर्थ

```text
Even with multiple threads on a multi-core CPU:
  Only ONE thread runs Python bytecode at any instant.
→ Threading does NOT give CPU-bound parallelism in CPython.
```

## मुख्य अंतर: CPU-बाउंड बनाम I/O-बाउंड

```python
import threading

# ❌ CPU-bound work with threads — NO speedup (GIL serializes them)
def cpu_task():
    sum(i * i for i in range(10_000_000))   # heavy computation
# 4 threads doing this run essentially as slow as 1 (GIL contention)

# ✅ I/O-bound work with threads — REAL benefit
def io_task():
    response = requests.get(url)   # waits on network — RELEASES the GIL while waiting
# while one thread waits on I/O, the GIL is freed for others → concurrency works
```

महत्वपूर्ण बारीकी: GIL **I/O के दौरान जारी किया जाता है** (नेटवर्क, फाइल, sleep) और कई C एक्सटेंशन के अंदर। इसलिए थ्रेड्स **I/O-बाउंड** कार्य के लिए **सहायक होते हैं** (एकाधिक प्रतीक्षाएं अतिव्यापी होती हैं), लेकिन **CPU-बाउंड** कार्य के लिए **नहीं होते** (GIL गणना को क्रमबद्ध करता है)।

## CPU-बाउंड कार्य के लिए GIL के चारों ओर काम करना

```python
from multiprocessing import Pool

# ✅ multiprocessing uses separate PROCESSES, each with its own GIL → true parallelism
with Pool(4) as p:
    results = p.map(cpu_task, data)   # runs on 4 cores genuinely in parallel
```

CPU-बाउंड समवर्तिता के लिए, **`multiprocessing`** (अलग प्रक्रियाएं एकल GIL को दरकिनार करती हैं), या पुस्तकालय (NumPy, आदि) का उपयोग करें जिसका भारी कार्य C में GIL जारी के साथ चलता है।

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

```text
I/O-bound (network, files, DB)  → threading or asyncio (GIL released on I/O)
CPU-bound (computation)          → multiprocessing (or C-extension libraries)
```

## भविष्य

```text
Python 3.13+ introduces an EXPERIMENTAL free-threaded (no-GIL) build,
and work continues to reduce the GIL's impact — but it remains the default reality.
```

## यह क्यों महत्वपूर्ण है

GIL Python की सबसे महत्वपूर्ण — और सबसे गलतफहमी — विशेषता है।

यह समझाता है **क्यों** CPU-भारी कार्य के लिए थ्रेड्स का उपयोग कोई गति नहीं देता (एक सामान्य गलती), और **क्यों** समवर्तिता के लिए सही उपकरण कार्यभार पर निर्भर करता है: **I/O-बाउंड के लिए थ्रेडिंग/asyncio** (जहां GIL प्रतीक्षा के दौरान जारी किया जाता है) और **CPU-बाउंड के लिए multiprocessing** (सच्ची समवर्तिता के लिए अलग प्रक्रियाएं)।

GIL के बारे में गलतफहमी से अप्रभावी समवर्तिता कोड मिलता है जो स्केल नहीं करता।

इसे जानना — और I/O-बनाम-CPU निर्णय जो इसे चलाता है — समवर्तीय Python लिखने के लिए आवश्यक है जो वास्तव में प्रदर्शन करता है।