Python для начинающих

Понимание GIL и влияние на многопоточность в CPython

192 views04:29

### Понимание GIL и влияние на многопоточность в CPython

Если вы пробовали разогнать Python многопоточностью и не получили ускорения — вы почти наверняка столкнулись с GIL. Давайте разберёмся, что это такое и когда он действительно мешает.

#### Что такое GIL простыми словами

GIL (Global Interpreter Lock) — это глобальная «блокировка интерпретатора» в CPython.
Она гарантирует, что байт-код Python выполняется только одним потоком одновременно, даже если у вас 8 ядер и 32 потока.

Зачем это сделано:

- упрощает работу со сборщиком мусора;
- упрощает реализацию многих внутренних структур;
- делает интерпретатор проще и стабильнее.

Цена — ограниченная масштабируемость по CPU в многопоточных программах на чистом Python-коде.

#### Важный нюанс: CPU-bound vs I/O-bound

Многопоточность в CPython не бесполезна. Важно, что именно делает ваш код:

- CPU-bound (много вычислений на процессоре) — GIL чаще всего убивает выгоду от потоков.
- I/O-bound (ожидание диска, сети, БД) — потоки отлично помогают прятать ожидание.

#### Классический пример, где потоки не ускоряют

import threading
import time

def cpu_heavy(n):
    count = 0
    for _ in range(n):
        count += 1
    return count

def run_threads():
    t1 = threading.Thread(target=cpu_heavy, args=(10_000_000,))
    t2 = threading.Thread(target=cpu_heavy, args=(10_000_000,))

    start = time.time()
    t1.start(); t2.start()
    t1.join(); t2.join()
    print("Threads:", time.time() - start)

def run_single():
    start = time.time()
    cpu_heavy(10_000_000)
    cpu_heavy(10_000_000)
    print("Single:", time.time() - start)

if __name__ == "__main__":
    run_single()
    run_threads()

На большинстве машин время выполнения будет похоже: два потока не нагружают два ядра независимо, потому что GIL не даёт им параллельно исполнять Python-байткод.

#### Где потоки действительно помогают

Когда поток ждёт I/O, многие C-функции освобождают GIL. Это позволяет другому потоку работать. Классический пример — сеть:

import threading
import requests
import time

urls = [
    "https://httpbin.org/delay/2",
    "https://httpbin.org/delay/2",
    "https://httpbin.org/delay/2",
]

def fetch(url):
    resp = requests.get(url)
    print(url, resp.status_code)

def run_threads():
    start = time.time()
    threads = [threading.Thread(target=fetch, args=(u,)) for u in urls]
    for t in threads: t.start()
    for t in threads: t.join()
    print("Threads:", time.time() - start)

def run_single():
    start = time.time()
    for u in urls:
        fetch(u)
    print("Single:", time.time() - start)

if __name__ == "__main__":
    run_single()
    run_threads()

Здесь многопоточность почти наверняка будет существенно быстрее, потому что пока один поток ждёт ответ сервера, другой может выполняться.

#### Как обходят ограничения GIL

- multiprocessing — запускает несколько процессов, у каждого свой интерпретатор и свой GIL.
- Расширения на C / Cython — тяжёлые вычисления выполняются в C-коде, который может освобождать GIL.
- Для I/O-нагруженных задач — потоки или asyncio.

Главная мысль: GIL — не баг, а особенность CPython. Он не запрещает многопоточность, но заставляет вас осознанно выбирать инструмент:
потоки для I/O, процессы и C-расширения — для тяжёлых вычислений.

👍3

252 views04:29