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-bound vs I/O-bound

```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-bound** कामासाठी *मदत करते* (अनेक प्रतीक्षा ओव्हरलॅप), परंतु **CPU-bound** कामासाठी *नाही* (GIL गणना क्रमबद्ध करते).

## CPU-bound कामासाठी 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-bound समांतरतेसाठी, **`multiprocessing`** वापरा (वेगळ्या प्रक्रियांमुळे एकल GIL हरवतात), किंवा लायब्ररी (NumPy इत्यादी) जांची जड कामे GIL सोडून C मध्ये चलते.

## निर्णय मार्गदर्शक

```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-bound साठी threading/asyncio** (जेथे GIL प्रतीक्षेदरम्यान सोडला जातो) आणि **CPU-bound साठी multiprocessing** (सत्य समांतरतेसाठी वेगळ्या प्रक्रिया).

GIL चा गैरसमज अप्रभावी समवर्तीता कोडकडे नेतो जो स्केल होत नाही.

हे जाणून घेणे — आणि I/O-vs-CPU निर्णय ते चालवते — वास्तविकपणे कार्यरत समवर्तीय Python लिहिण्यासाठी आवश्यक आहे.