Çfarë është GIL dhe si ndikon në përkudhetësinë?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) është një mutex në CPython (implementimi standard i Python) që lejon vetëm **një thread të ekzekutojë Python bytecode në të njëjtën kohë**. Kjo do të thotë se threadet e Python nuk mund të ekzekutojnë kod Python në paralelizëm të vërtetë në më shumë bërthamave CPU — një konsideratë e rëndësishme për përkudhetësinë.

## Çfarë do të thotë GIL në praktikë

```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.
```

## Dallimi themelor: 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
```

Një nuancë vendimtare: GIL **lirohet gjatë I/O** (rrjet, skedar, sleep) dhe brenda shumë ekstensioneve C. Prandaj threadet *ndihmojnë* për punën **I/O-bound** (shumë pritje mbivendosen), por *jo* për punën **CPU-bound** (GIL serizalizon llogaritjet).

## Përqarkimin e GIL për punën CPU-bound

```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
```

Për paralelizmin CPU-bound, përdorni **`multiprocessing`** (proceset të ndarë anashkalojnë GIL-in e vetëm), ose biblioteka (NumPy, etj.) puna e rënde e të cilave ekzekutohet në C me GIL-in e liruar.

## Udhëzuesi i vendimit

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

## E ardhja

```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.
```

## Pse ka rëndësi

GIL është një nga karakteristikat më të rëndësishme — dhe më të keqkuptuara — të Python.

Shpjegon *pse* përdorimi i threadeve për punën intensive të CPU nuk jep përshpejtim (një gabim i zakonshëm), dhe *pse* mjeti i duhur i përkudhetësisë varet nga ngarkesa e punës: **threading/asyncio për I/O-bound** (ku GIL lirohet gjatë pritjeve) dhe **multiprocessing për CPU-bound** (proceset të ndarë për paralelizmin e vërtetë).

Nezgjedhja e GIL çon në kod përkudhetësie jo efektive që nuk shkallëzohet.

Pajisja e tij — dhe vendimi I/O-vs-CPU që ai çon — është thelbësore për të shkruar Python përkudhetëse që në të vërtetë funksionon.