Mikä on GIL ja miten se vaikuttaa rinnakkaisuuteen?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) on mutex CPythonissa (vakiomuotoinen Python-toteutus), joka sallii vain **yhden säikeen suorittaa Python-tavukoodia kerrallaan**. Tämä tarkoittaa, että Python-säikeet eivät voi suorittaa Python-koodia todellisesti rinnakkain useilla CPU-ytimillä — merkittävä huomio rinnakkaisuutta suunniteltaessa.

## Mitä GIL käytännössä tarkoittaa

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

## Tärkeä erottelu: CPU-sitoutunut vs I/O-sitoutunut

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

Ratkaiseva subtiliteetti: GIL **vapautetaan I/O-toiminnon aikana** (verkko, tiedosto, sleep) ja monien C-laajennusten sisällä. Joten säikeet *auttavat* **I/O-sitoutuneella** työllä (useita odotuksia voi olla päällekkäin), mutta *eivät* **CPU-sitoutuneella** työllä (GIL sarjaloittaa laskentaa).

## GIL:n kiertäminen CPU-sitoutuneessa työssä

```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-rinnakkaisen laskennan osalta käytä **`multiprocessing`**-moduulia (erilliset prosessit kiertävät yksittäisen GIL:n), tai kirjastoja (NumPy jne.), joiden raskas työ suoritetaan C:ssä GIL:ä vapautettaessa.

## Päätösprosessin opas

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

## Tulevaisuus

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

## Miksi se on tärkeää

GIL on yksi Pythonin tärkeimmistä — ja useimmiten väärinymmärretyimmistä — ominaisuuksista.

Se selittää, *miksi* säikeiden käyttö CPU-raskaassa työssä ei nopeuta suoritusta (yleinen virhe), ja *miksi* oikea rinnakkaisuustyökalu riippuu työkuormasta: **threading/asyncio I/O-sitoutuneelle** (jossa GIL vapautetaan odotuksien aikana) ja **multiprocessing CPU-sitoutuneelle** (erilliset prosessit todellista rinnakkaista toteutusta varten).

GIL:n väärinymmärtäminen johtaa tehottomaan rinnakkaisuuskoodiin, joka ei skaalaudu.

Sen tunteminen — ja sen ajama I/O-vs-CPU-päätös — on välttämätöntä rinnakkaiselle Pythonille, joka todella toimii.