GIL ਕੀ ਹੈ ਅਤੇ ਇਹ concurrency ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਤ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) CPython (ਮਾਨਕ Python ਲਾਗੂਕਰਣ) ਵਿੱਚ ਇੱਕ mutex ਹੈ ਜੋ ਇੱਕ ਸਮੇਂ **ਸਿਰਫ ਇੱਕ ਥ੍ਰੈਡ ਨੂੰ Python bytecode ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ**। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ Python ਥ੍ਰੈਡਸ ਇੱਕ ਤੋਂ ਵੱਧ CPU ਕੋਰਸ ਉੱਤੇ ਸਚਮੁੱਚ ਸਮਾਨਾਂਤਰ ਵਿੱਚ Python ਕੋਡ ਨਹੀਂ ਚਲਾ ਸਕਦੇ — concurrency ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਵਿਚਾਰ।

## ਵਿਅਕਤੀਗਤ ਰੂਪ ਵਿੱਚ 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 ਦੌਰਾਨ ਛੱਡੀ ਜਾਂਦੀ ਹੈ** (ਨੈੱਟਵਰਕ, ਫਾਈਲ, ਸਲੀਪ) ਅਤੇ ਬਹੁਤ ਸਾਰੇ C ਐਕਸਟੈਨਸ਼ਨਾਂ ਦੇ ਅੰਦਰ। ਇਸ ਲਈ ਥ੍ਰੈਡਸ **I/O-ਬਾਂਧ** ਕੰਮ ਲਈ *ਅਸਲ* ਮਦਦ ਕਰਦੇ ਹਨ (ਅਲਗ ਵੇਖਭਾਲ ਓਵਰਲੈਪ), ਪਰ **CPU-ਬਾਂਧ** ਕੰਮ ਲਈ *ਨਹੀਂ* (GIL ਕੰਪਿਊਟੇਸ਼ਨ ਨੂੰ serializes ਕਰਦਾ ਹੈ)।

## 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, ਆਦਿ) ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਨ੍ਹਾਂ ਦਾ ਭਾਰੀ ਕੰਮ 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-ਭਾਰੀ ਕੰਮ ਲਈ ਥ੍ਰੈਡਸ ਦੀ ਵਰਤੋਂ ਕੋਈ ਗਤੀ ਨਹੀਂ ਦਿੰਦੀ (ਇੱਕ ਆਮ ਗਲਤੀ), ਅਤੇ *ਕਿਉਂ* ਸਹੀ concurrency ਟੂਲ ਵਰਕਲੋਡ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ: **I/O-ਬਾਂਧ ਲਈ threading/asyncio** (ਜਿੱਥੇ GIL ਵੇਖਭਾਲ ਦੌਰਾਨ ਛੱਡੀ ਜਾਂਦੀ ਹੈ) ਅਤੇ **CPU-ਬਾਂਧ ਲਈ multiprocessing** (ਸਚਮੁੱਚ ਸਮਾਨਾਂਤਰਤਾ ਲਈ ਵੱਖਰੀ ਪ੍ਰਕ੍ਰਿਆਵਾਂ)।

GIL ਦੀ ਗਲਤਫਹਮੀ ਅਕੁਸ਼ਲ concurrency ਕੋਡ ਨੂੰ ਜਾਂਦੀ ਹੈ ਜੋ ਸਕੇਲ ਨਹੀਂ ਕਰਦਾ।

ਇਸ ਨੂੰ ਜਾਣਨਾ — ਅਤੇ I/O-ਬਨਾਮ-CPU ਫੈਸਲਾ ਜੋ ਇਹ ਚਲਾਉਂਦਾ ਹੈ — concurrent Python ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਵਾਪਸੀ ਕਰਦਾ ਹੈ।