GIL என்றால் என்ன மற்றும் அது ஒப்பிசைப்பை எவ்வாறு பாதிக்கிறது?

Question

Accepted Answer

**GIL** (Global Interpreter Lock) என்பது CPython (Python இன் தரமான செயல்படுத்தல்) இல் ஒரு mutex ஆகும், இது **ஒரு நேரத்தில் ஒரு நூல் மட்டுமே Python bytecode ஐ செயல்படுத்த அனுமதிக்கிறது**. இதன் பொருள் Python நூல்கள் பல CPU கோர்களில் உண்மையான இணையாக Python குறியீட்டை இயக்க முடியாது — இது ஒப்பிசைப்புக்கான முக்கியமான கருத்தாக்கம்.

## 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-பிணைக்கப்பட்ட vs 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 க்கு போது விடுவிக்கப்படுகிறது** (நெটவொர்க், கோப்பு, sleep) மற்றும் பல C நீட்டிப்புகளுக்குள். எனவே நூல்கள் **I/O-பிணைக்கப்பட்ட** வேலைக்கு *உதவுகின்றன* (பல மெய்தல்கள் ஒன்றுக்கொன்று இணைகின்றன), ஆனால் **CPU-பிணைக்கப்பட்ட** வேலைக்கு *அல்ல* (GIL கணனை வரிசைப்படுத்துகிறது).

## 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, முதலியவை) பயன்படுத்தவும், அதன் கனமான வேலை C இல் இயங்குகிறது GIL விடுவிக்கப்பட்ட நிலையில்.

## முடிவு வழிகாட்டி

```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-கனமான வேலைக்கு நூல்களைப் பயன்படுத்துவது *ஏன்* வேகத்தை அளிக்கவில்லை (ஒரு பொதுவான தவறு) என்பதையும், சரியான ஒப்பிசைப்பு கருவி பணிச்சுமையைப் பொறுத்து *ஏன்* இருக்கிறது என்பதையும் இது விளக்குகிறது: **I/O-பிணைக்கப்பட்டவற்றுக்கு threading/asyncio** (GIL மெய்தல்களின் போது விடுவிக்கப்படுகிறது) மற்றும் **CPU-பிணைக்கப்பட்டவற்றுக்கு multiprocessing** (உண்மையான இணைத்தலுக்கான தனிப்பட்ட செயல்முறைகள்).

GIL பற்றிய பிழையான புரிதல் பலனளிக்காத ஒப்பிசைப்பு குறியீட்டுக்கு வழிவகுக்கிறது.

தெரிந்து கொள்ளல் — மற்றும் இது இயக்குவது I/O-vs-CPU முடிவு — உண்மையில் பல செயல்படும் ஒப்பிசைப்பு Python எழுதுவதற்கு அத்தியாவசியமாகும்.