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-બાઉન્ડ vs 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-vs-CPU નિર્ણય જે તે ચલાવે છે — Python સમવર્તિતા લખવા માટે આવશ્યક છે જે ખરેખર કાર્ય કરે છે.