Vad är GIL och hur påverkar det concurrency?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) är en mutex i CPython (standardimplementationen av Python) som tillåter endast **en tråd att köra Python bytecode åt gången**. Detta betyder att Python-trådar inte kan köra Python-kod i sann parallellitet på flera CPU-kärnor — en viktig övervägning för concurrency.

## Vad GIL betyder i praktiken

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

## Den viktiga skillnaden: CPU-bunden vs I/O-bunden

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

Den avgörande nyansen: GIL **frigörs under I/O** (nätverk, fil, sleep) och inuti många C-tillägg. Så trådar *hjälper* för **I/O-bunden** arbete (flera väntningar överlappar), men *inte* för **CPU-bunden** arbete (GIL serialiserar beräkningar).

## Att kringgå GIL för CPU-bundet arbete

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

För CPU-bunden parallellitet, använd **`multiprocessing`** (separata processer kringgår den enda GIL), eller bibliotek (NumPy, etc.) vars tunga arbete körs i C med GIL frigiven.

## Beslutsguiden

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

## Framtiden

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

## Varför det spelar roll

GIL är en av Pythons viktigaste — och mest missförstådd — karakteristikor.

Det förklarar *varför* användning av trådar för CPU-tunga arbete ger ingen hastighetsökning (ett vanligt misstag), och *varför* rätt concurrency-verktyg beror på arbetsbelastningen: **threading/asyncio för I/O-bunden** (där GIL frigörs under väntningar) och **multiprocessing för CPU-bunden** (separata processer för sann parallellitet).

Missförståelse om GIL leder till ineffektiv concurrency-kod som inte skalas.

Att veta det — och I/O-vs-CPU-beslutet det driver — är väsentligt för att skriva concurrency-Python som faktiskt presterar.