Конкурентность, параллелизм и GIL

Конкурентность и параллелизм

• Конкурентность — умение вести несколько задач одновременно «в процессе». Повар ставит воду, пока она греется — режет овощи, потом помешивает соус. Повар один, но задачи продвигаются вместе.
• Параллелизм — задачи выполняются буквально одновременно. Три повара на трёх плитах.

Конкурентность — про структуру программы (как не простаивать при ожидании), параллелизм — про исполнение (использовать несколько ядер).

Два вида нагрузки

import time, asyncio

async def fake_request(i):
    await asyncio.sleep(0.3)               # «ждём сеть»: процессор свободен
    return i

async def main():
    start = time.perf_counter()
    for i in range(3):                     # последовательно: 3 × 0.3 с
        await fake_request(i)
    print(f"последовательно: {time.perf_counter() - start:.1f} с")

    start = time.perf_counter()
    await asyncio.gather(*(fake_request(i) for i in range(3)))   # конкурентно: ждём вместе
    print(f"конкурентно:     {time.perf_counter() - start:.1f} с")

asyncio.run(main())

Ожидание можно совместить. А вот вычисления — нет: если задачи считают, а не ждут, одно ядро не станет работать быстрее от того, что задачи чередуются.

Процессы, потоки, корутины

GIL

Global Interpreter Lock — мьютекс в CPython: в каждый момент времени байткод Python в процессе выполняет только один поток.

Зачем он нужен:

• управление памятью CPython построено на подсчёте ссылок; без GIL каждое x = y требовало бы атомарных операций или блокировок — это замедлило бы однопоточный код;
• C-расширения проще писать безопасно.

Что это значит на практике:

• CPU-bound код на чистом Python потоками не ускоряется — потоки по очереди держат GIL.
• I/O-bound код ускоряется: при ожидании сети, диска, time.sleep поток отпускает GIL.
• Библиотеки на C (numpy, hashlib на больших данных, сжатие zlib) тоже отпускают GIL во время тяжёлых вычислений — их можно распараллеливать потоками.
• Поток отдаёт GIL и принудительно — раз в 5 мс (sys.getswitchinterval()), чтобы другие потоки не голодали.

import threading, time

def count(n):
    while n > 0:
        n -= 1

N = 30_000_000
start = time.perf_counter()
count(N); count(N)
print(f"последовательно: {time.perf_counter() - start:.2f} с")   # ≈ 1.6 с

start = time.perf_counter()
t1 = threading.Thread(target=count, args=(N,))
t2 = threading.Thread(target=count, args=(N,))
t1.start(); t2.start(); t1.join(); t2.join()
print(f"два потока:      {time.perf_counter() - start:.2f} с")   # ≈ 1.6 с — не быстрее!

(В браузерном Python потоков нет, поэтому пример без кнопки запуска.)

Как выбрать

Опасности конкурентности

Следующие уроки разбирают каждый инструмент на практике.

Итог

• Конкурентность — чередование задач, параллелизм — одновременное выполнение на разных ядрах.
• I/O-bound → asyncio или потоки; CPU-bound → процессы.
• GIL: один поток выполняет байткод в каждый момент; отпускается при вводе-выводе.
• GIL не заменяет блокировки для ваших данных.