Конкурентность и GIL

GIL (Global Interpreter Lock) — мьютекс, позволяющий лишь одному потоку выполнять байткод Python одновременно и защищающий внутренности интерпретатора, например счётчики ссылок. Отпускается на I/O.

async def определяет корутину; await приостанавливает её до завершения awaitable, отдавая управление однопоточному событийному циклу, который тем временем запускает другие готовые корутины. Без лишних потоков.

Корутина обобщает подпрограмму: у неё несколько точек входа, она приостанавливается и возобновляется, сохраняя состояние. В Python их пишут через async def/await (или yield), давая кооперативность.

Да — модуль threading создаёт нативные потоки ОС (POSIX/Windows), которые планирует операционная система, а не зелёные потоки уровня интерпретатора. GIL всё равно сериализует исполнение их байткода.

Потоки делят одно адресное пространство — ту же память, переменные и модули — поэтому общаются дёшево, но требуют синхронизации. Процессы независимы, имеют раздельные пространства и используют IPC.

Используйте asyncio.gather для конкурентного запуска корутин на одном потоке: await asyncio.gather(fetch(1), fetch(2), fetch(3)). await asyncio.sleep уступает управление, поэтому все три перекрываются и завершаются за ~1с, а не 3с. Блокирующий time.sleep застопорил бы цикл.

Два потока не быстрее последовательного запуска — часто медленнее, из-за борьбы за GIL — потому что count это чистая Python-нагрузка на CPU, а GIL пускает лишь один поток исполнять байткод одновременно. Чтобы распараллелить, используйте multiprocessing.Process или ProcessPoolExecutor.

Выигрывают I/O-bound задачи: поток отпускает GIL пока ждёт сеть или диск, давая другим работать, и конкурентность скрывает задержки. CPU-bound задачи нет — GIL сериализует их.

У каждого процесса свой интерпретатор и свой GIL, поэтому процессы исполняют байткод Python в настоящем параллелизме по ядрам, обходя сериализацию единым GIL, что тормозит потоки на CPU-bound.

Гонка данных: counter += 1 — это «чтение-изменение-запись», не атомарная на уровне байткода, поэтому потоки чередуются и теряют обновления; GIL гарантирует атомарность байткода, но не многошаговых операций. Решение: защитить инкремент через threading.Lock.

Инверсия порядка блокировок: t1 берёт a, затем b, а t2 — b, затем a. Если каждый захватит свою первую блокировку одновременно, второй не достанется никому → дедлок. Решение: захватывать блокировки в едином глобальном порядке или использовать таймаут (lock.acquire(timeout=...)).

Лёгкие потоки в пространстве пользователя, которые планирует среда или библиотека (greenlet, gevent), невидимые для ОС — для неё процесс выглядит однопоточным. Библиотека переключает их кооперативно.

Используйте ProcessPoolExecutor, чтобы обойти GIL: with ProcessPoolExecutor() as pool: results = list(pool.map(square, range(10))). У каждого процесса свой интерпретатор и GIL, поэтому работа идёт по-настоящему параллельно. Функция и аргументы должны быть picklable.

Это блокирует весь событийный цикл: один поток исполняет все корутины кооперативно, и управление уступает лишь await, поэтому синхронный блокирующий вызов тормозит все прочие корутины до возврата.

Используйте asyncio с асинхронным HTTP-клиентом (например aiohttp), читая заголовок ответа Server на каждый сайт. Ограничьте конкурентность через asyncio.Semaphore — без него исчерпаете сокеты/дескрипторы. Задайте таймаут на запрос и оберните каждый запрос в try/except, чтобы один сбой не утопил пакет (считая его unknown). Стримьте CSV, а не грузите целиком. Сокеты/дескрипторы кончатся первыми: работа I/O-bound, поэтому CPU и память низки, пока открытые соединения копятся.

Да. GIL и так сериализует байткод, поэтому ускорения нет; вдобавок рантайм постоянно гоняет захват/освобождение GIL между конкурирующими потоками, и эти чистые накладные расходы на переключение могут утянуть пропускную способность ниже однопоточной.

Используйте asyncio: однопоточный событийный цикл дёшево обслуживает огромное число конкурентных ожиданий I/O — именно эта нагрузка. Потоки добавляют накладные расходы OS-потоков и переключений, не масштабируясь на миллион; процессы — для CPU-задач и тратят память зря; однопоточный вариант слишком медленный. Ограничьте конкурентность через asyncio.Semaphore, чтобы не исчерпать сокеты и дескрипторы, и собирайте результаты по URL.