PrepBro
← Назад к вопросам

Какие знаешь названия асинхронных сущностей в Python?

2.0 Middle🔥 171 комментариев
#Асинхронность и многопоточность

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Асинхронные сущности в Python

Асинхронное программирование в Python основано на концепции управления потоком выполнения без блокировки. Существует множество сущностей для работы с асинхронным кодом.

1. Coroutine (Корутина)

# Корутина — функция, которая может приостановить выполнение
import asyncio

async def my_coroutine():
    """Это корутина"""
    await asyncio.sleep(1)
    return "Done"

# Создание корутины
coro = my_coroutine()
print(type(coro))  # <class 'coroutine'>

# Выполнение
result = asyncio.run(my_coroutine())
print(result)  # Done

# ✅ Плюсы:
# - Основная единица асинхронного кода
# - Может быть приостановлена и возобновлена
# - Эффективнее потоков

# ❌ Минусы:
# - Требует event loop
# - Нельзя запустить как обычную функцию

2. Task (Задача)

# Task — обёртка над корутиной, добавляет управление
import asyncio

async def fetch_data(url: str):
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    # Создание task'а
    task1 = asyncio.create_task(fetch_data("http://api.example.com"))
    task2 = asyncio.create_task(fetch_data("http://api2.example.com"))
    
    # Ожидание выполнения
    results = await asyncio.gather(task1, task2)
    print(results)

asyncio.run(main())

# Отличие от coroutine:
# - Task планируется в event loop сразу
# - Можно отменить (cancel)
# - Можно получить состояние (done, cancelled)

# ✅ Плюсы:
# - Параллельное выполнение
# - Управление жизненным циклом
# - Можно отменить

3. Future (Будущее)

# Future — результат, который будет доступен в будущем
import asyncio

async def main():
    loop = asyncio.get_event_loop()
    
    # Создание Future
    future = loop.create_future()
    
    # Обработка в фоне
    async def set_future_result():
        await asyncio.sleep(1)
        future.set_result("Result")
    
    asyncio.create_task(set_future_result())
    
    # Ожидание результата
    result = await future
    print(result)  # Result

asyncio.run(main())

# ✅ Плюсы:
# - Синхронизация между корутинами
# - Позволяет встроить асинхронный код в синхронный

# ❌ Минусы:
# - Низкоуровневая абстракция
# - Task'и обычно удобнее

4. Event Loop (Цикл событий)

# Event Loop — сердце асинхронной программы
import asyncio

async def greet(name):
    print(f"Hello, {name}!")
    await asyncio.sleep(1)
    print(f"Goodbye, {name}!")

# Способ 1: asyncio.run() (Python 3.7+)
asyncio.run(greet("Alice"))

# Способ 2: получить текущий loop
loop = asyncio.get_event_loop()
loop.run_until_complete(greet("Bob"))

# Способ 3: manual loop (редко)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
    loop.run_until_complete(greet("Charlie"))
finally:
    loop.close()

# Event Loop отвечает за:
# - Планирование корутин
# - Обработку I/O операций
# - Выполнение callbacks

5. Awaitable (Ожидаемое)

# Awaitable — объект, который можно ожидать (await)
import asyncio
from typing import Awaitable

# Корутины
async def my_coro() -> Awaitable[str]:
    return "result"

# Task'и
task: Awaitable[str] = asyncio.create_task(my_coro())

# Future'ы
future: Awaitable[str] = asyncio.Future()

# Любой объект с методом __await__
class MyAwaitable:
    def __await__(self):
        yield
        return "custom awaitable"

async def use_awaitable():
    result = await MyAwaitable()
    print(result)  # custom awaitable

# Всё, что можно использовать с await

6. Iterator и AsyncIterator

# Обычный iterator
def sync_generator():
    for i in range(3):
        yield i

# Асинхронный iterator
async def async_generator():
    for i in range(3):
        await asyncio.sleep(0.1)
        yield i

async def main():
    # Обычный
    for value in sync_generator():
        print(f"Sync: {value}")
    
    # Асинхронный
    async for value in async_generator():
        print(f"Async: {value}")

asyncio.run(main())

# ✅ AsyncIterator удобен для:
# - Потоков данных
# - Чтения файлов асинхронно
# - WebSocket'ов

7. Context Manager и AsyncContextManager

# Асинхронный контекстный менеджер
import asyncio

class AsyncConnection:
    async def __aenter__(self):
        print("Connecting...")
        await asyncio.sleep(0.5)
        print("Connected")
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("Disconnecting...")
        await asyncio.sleep(0.5)
        print("Disconnected")
    
    async def query(self, sql: str):
        await asyncio.sleep(0.1)
        return f"Result of {sql}"

async def main():
    async with AsyncConnection() as conn:
        result = await conn.query("SELECT * FROM users")
        print(result)

asyncio.run(main())

# ✅ Для:
# - Управления ресурсами
# - Асинхронных подключений к БД
# - HTTP клиентов

8. Callback (Обратный вызов)

# Callbacks в асинхронном коде
import asyncio

async def async_operation():
    await asyncio.sleep(1)
    return "Result"

def on_done(task):
    """Callback когда task завершился"""
    result = task.result()
    print(f"Task done with result: {result}")

async def main():
    task = asyncio.create_task(async_operation())
    task.add_done_callback(on_done)  # Добавить callback
    
    await task

asyncio.run(main())

# ✅ Для:
# - Реакции на завершение task'а
# - Обработки результатов

# ❌ Минусы:
# - Menos readable чем await
# - Сложнее обработка ошибок

9. Lock (Блокировка) и Semaphore

# Асинхронные примитивы синхронизации
import asyncio

# Lock — взаимное исключение
lock = asyncio.Lock()

async def critical_section():
    async with lock:
        print("In critical section")
        await asyncio.sleep(1)
        print("Leaving critical section")

async def main():
    await asyncio.gather(
        critical_section(),
        critical_section(),
        critical_section(),
    )

asyncio.run(main())

# Semaphore — ограничение количества
sem = asyncio.Semaphore(2)  # Макс 2 одновременно

async def limited_task(id):
    async with sem:
        print(f"Task {id} acquired semaphore")
        await asyncio.sleep(1)
        print(f"Task {id} released semaphore")

# ✅ Для:
# - Rate limiting
# - Защиты критических секций
# - Ограничения нагрузки

10. Event (Событие)

# Event — сигнал между корутинами
import asyncio

event = asyncio.Event()

async def waiter():
    print("Waiter: waiting for event")
    await event.wait()
    print("Waiter: event received!")

async def setter():
    await asyncio.sleep(2)
    print("Setter: setting event")
    event.set()

async def main():
    await asyncio.gather(
        waiter(),
        waiter(),
        setter(),
    )

asyncio.run(main())

# ✅ Для:
# - Синхронизации
# - Оповещения группы корутин

11. Condition (Условие)

# Condition — Lock + Event
import asyncio

condition = asyncio.Condition()
data = None

async def consumer():
    async with condition:
        await condition.wait()
        print(f"Consumer got data: {data}")

async def producer():
    global data
    await asyncio.sleep(1)
    async with condition:
        data = "Important data"
        condition.notify()  # Разбудить одного
        # или condition.notify_all()  # Разбудить всех

async def main():
    await asyncio.gather(
        consumer(),
        consumer(),
        producer(),
    )

asyncio.run(main())

12. Queue (Очередь)

# AsyncQueue — для передачи данных между корутинами
import asyncio

queue = asyncio.Queue(maxsize=3)

async def producer():
    for i in range(5):
        await queue.put(f"Item {i}")
        print(f"Produced item {i}")
        await asyncio.sleep(0.5)

async def consumer():
    while True:
        item = await queue.get()
        print(f"Consumed {item}")
        await asyncio.sleep(1)
        queue.task_done()

async def main():
    await asyncio.gather(
        producer(),
        consumer(),
        consumer(),
    )

asyncio.run(main())

13. Gather и Wait

# Ожидание нескольких корутин
import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    return f"Task {name} done"

async def main():
    # gather — ждёт всех, результаты в порядке
    results = await asyncio.gather(
        task("A", 1),
        task("B", 2),
        task("C", 1),
    )
    print(results)
    
    # wait — больше контроля
    tasks = [
        asyncio.create_task(task("X", 1)),
        asyncio.create_task(task("Y", 2)),
    ]
    
    done, pending = await asyncio.wait(
        tasks,
        timeout=1.5,  # Timeout
    )
    
    print(f"Done: {done}, Pending: {pending}")

asyncio.run(main())

Сравнение асинхронных сущностей

Сущность           | Использование
====================================
Coroutine          | Базовая единица асинхронного кода
Task               | Управление и отмена корутин
Future             | Синхронизация результатов
Event Loop         | Планирование и выполнение
Lock/Semaphore     | Синхронизация доступа
Event              | Сигнальное оповещение
Queue              | Передача данных
AsyncIterator      | Потоки данных
AsyncContextManager| Управление ресурсами

Итоги

Асинхронные сущности в Python:

  • Coroutine — основная единица
  • Task — управляемая корутина
  • Future — результат в будущем
  • Event Loop — планировщик
  • Lock/Semaphore — синхронизация
  • Event/Condition — сигналы
  • Queue — передача данных
  • AsyncIterator/AsyncContextManager — итерация и ресурсы