What is the GIL-free approach for CPU-bound tasks in Python?

Question

Accepted Answer

**Multiprocessing** is the primary way to bypass the GIL for CPU-bound tasks.

```python
from multiprocessing import Pool, cpu_count
import time

def cpu_heavy(n):
    return sum(i * i for i in range(n))

# Compare single vs multi-process
start = time.time()
result = cpu_heavy(10**7)
single = time.time() - start

start = time.time()
with Pool(cpu_count()) as pool:
    chunk_size = 10**7 // cpu_count()
    chunks = [chunk_size] * cpu_count()
    results = pool.map(cpu_heavy, chunks)
    result = sum(results)
multi = time.time() - start

print(f"Single: {single:.2f}s, Multi: {multi:.2f}s")
```

**Other approaches:**
- **C extensions** (NumPy, Cython) — release GIL.
- **Numba** — JIT compilation.
- **subprocess** — separate interpreter.
- **Alternative implementations**: PyPy, Jython.

**When multiprocessing is NOT the answer:**
- Large data (serialization overhead).
- Frequent communication between workers.

Python: What is the GIL-free approach for CPU-bound tasks in Python?