Cad is GIL ann agus conas a théann sé i bhfeidhm ar chomhthreabhadh?

Question

Accepted Answer

Is é an **GIL** (Global Interpreter Lock) mutex i CPython (an fhíordhleachtas Python) a cheadaíonn do dhíreach **snáithe amháin Python bytecode a fhorghníomhú ag an am céanna**. Ciallaíonn sé seo nach féidir le snáithe Python cód Python a rith i bhfíor-chomhthreabhadh ar iomadúil bhréagánacha CPU — breithniú tábhachtach do chomhthreabhadh.

## Cad atá i gceist ag an GIL i ndáiríbh

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

## An geal-idirdhealú: obair CPU-bhunaithe i gcomparáid le obair I/O-bhunaithe

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

An geal riachtanach: tá an GIL **scaoilte le linn I/O** (gréasán, comhad, codladh) agus taobh istigh de go leor eisínteachta C. Mar sin, tugann snáithe **cabhrú do obair I/O-bhunaithe** (forshníomh iomadúil), ach **ní dhéanann siad cabhrú do obair CPU-bhunaithe** (an GIL a shrianadh ríomh).

## Ag oibriú timpeall ar an GIL do obair CPU-bhunaithe

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

Mar obair CPU-bhunaithe comhthreabhadh, úsáid **`multiprocessing`** (próisis ar leith foluain an GIL singil), nó leabharlanna (NumPy, etc.) a bhfuil an obair throm acu ag rith i C agus an GIL scaoilte.

## An treoir cinneadh

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

## An todhchaí

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

## Cén fáth a bhfuil sé tábhachtach

Is é an GIL ceann de shaintréithe is tábhachtaí — agus is mí-thuigthe — Python.

Tugann sé míniú ar **cén fáth** nach tugann úsáid snáithe do obair CPU-throm aon fhás tapa (earráid choitianta), agus **cén fáth** go mbraitheann an uirlis cheart do chomhthreabhadh ar an obair: **snáithe/asyncio do I/O-bhunaithe** (áit a scaoiltear an GIL le linn feitheamh) agus **multiprocessing do CPU-bhunaithe** (próisis ar leith do fhíor-chomhthreabhadh).

Mí-thuigsint ar an GIL a bhíonn mar thoradh ar chód comhthreabhadh neamhéifeachtach nach dtéann ar scála.

Gé go dtuigeann tú é — agus an cinneadh I/O-vs-CPU a thiomáineann sé — is riachtanach a bheith aici do scríobh comhthreabhadh Python a fheidhmíonn i ndáiríbh.