Перейти на PRO

Что произойдет, если в корутине asyncio использовать блокирующую операцию ввода-вывода, например, open().read()?

Тип вопроса: Асинхронность Вероятность: 10% Категория: Python Разработчик

Ответ

Использование синхронной блокирующей операции, такой как open().read(), внутри корутины полностью заблокирует цикл событий (event loop) asyncio.

Пока выполняется длительная блокирующая операция, event loop не может переключаться на другие задачи. В результате все остальные корутины останавливаются и ждут ее завершения. Это сводит на нет все преимущества асинхронности и может привести к "зависанию" всего приложения.

Неправильно (блокирует event loop):

import asyncio

async def blocking_task():
    print("Начинаю читать большой файл...")
    # Эта операция блокирует весь event loop
    with open('large_file.dat', 'rb') as f:
        _ = f.read()
    print("Файл прочитан.")

# Другие задачи не смогут выполниться, пока файл не будет прочитан

Правильные подходы:

  1. Использовать асинхронные библиотеки, например aiofiles. Они специально разработаны для интеграции с event loop.

    import aiofiles

async def non_blocking_read():
    async with aiofiles.open('large_file.dat', mode='rb') as f:
        contents = await f.read()
    print("Файл прочитан асинхронно.")

  2. Вынести блокирующий код в отдельный поток с помощью loop.run_in_executor(). Это позволяет event loop продолжать работу, пока блокирующая операция выполняется в фоновом потоке.

    async def run_in_executor_read():
    loop = asyncio.get_running_loop()
    with open('large_file.dat', 'rb') as f:
        # Делегируем блокирующий вызов f.read() в пул потоков
        await loop.run_in_executor(None, f.read)
    print("Файл прочитан в отдельном потоке.")

Ключевой вывод: никогда не используйте длительные блокирующие вызовы (I/O, CPU-bound) напрямую в корутинах. Всегда используйте await с асинхронными функциями или делегируйте блокирующий код в executor.

Ответ 18+ 🔞

А, слушай, смотри, тут такая ебаная история, которую многие наступают, как на грабли. Прям классика, блядь.

Вот представь: у тебя есть корутина, асинхронная, красивая, всё по феншую. И ты внутри неё, сука, делаешь такую штуку: open('file.txt').read(). Ну, чтение файла, обычное, синхронное. И думаешь: "Ну и хуй с ним, прочитаю и дальше пойду".

А на деле получается ёперный театр! Пока твой файл читается — а если он большой, то это может быть овердохуища секунд — твой весь цикл событий (event loop) встаёт колом. Он же синхронная операция! Она не отдаёт управление. И все остальные твои корутины, которые там в фоне что-то делают — запросы слали, сокеты слушали — они все, блядь, замирают. Просто ждут, пока этот файловый мудак дочитается. Вся асинхронность накрывается медным тазом, приложение выглядит так, будто его кто-то впендюрил.

Вот смотри, как НЕ НАДО делать, если не хочешь, чтобы тебя потом ебали в сраку:

import asyncio

async def blocking_task():
    print("Начинаю читать большой файл...")
    # А вот эта строчка — она пиздец как блокирует
    with open('large_file.dat', 'rb') as f:
        _ = f.read()  # Event loop тут кончился. Все задачи — в анабиозе.
    print("Файл прочитан.")

Всё, приехали. Пока read() не отработает, event loop — труп. Другие задачи — замороженные мартышлюшки.

Так как же, блядь, правильно?

Есть два основных пути, чтобы не быть пидарасом шерстяным.

1. Использовать асинхронные библиотеки. Для файлов есть, например, aiofiles. Она делает то же самое, но через await, не блокируя всех вокруг.

import aiofiles

async def non_blocking_read():
    async with aiofiles.open('large_file.dat', mode='rb') as f:
        contents = await f.read()  # А вот тут event loop жив-здоров и может переключаться!
    print("Файл прочитан асинхронно.")

2. Засунуть блокирующую хуйню в отдельный поток. У asyncio для этого есть run_in_executor. Смысл в том, что тяжелая синхронная работа уходит в фоновый поток, а event loop в это время продолжает крутиться и обслуживать других.

async def run_in_executor_read():
    loop = asyncio.get_running_loop()
    def read_file():
        with open('large_file.dat', 'rb') as f:
            return f.read()
    # Делегируем эту пытку в пул потоков. Event loop свободен.
    data = await loop.run_in_executor(None, read_file)
    print("Файл прочитан в отдельном потоке.")

Короче, вывод, блядь, простой, как три копейки: если видишь в корутине что-то долгое и синхронное (файлы, сетевые запросы без async/await, тяжёлые вычисления) — это красная тряпка. Либо ищи асинхронный аналог, либо пихай в executor. Иначе получишь иллюзию асинхронности, а на деле — одно большое "подождите, ща всё зависнет".

© ХакСобесов, 2026
support@hacksobesov.com