# Лабораторная работа 6. Асинхронный код (asyncio)

**Время на работу:** 2 пары. **Зависимости:** лабы 1–2.

## Цель работы

Освоить кооперативную многозадачность: `async/await`, event loop, `gather`,
ограничение конкурентности семафором. Понять, чем asyncio отличается от
потоков и когда выбирать её.

## Теория

### Модель: один поток, но тысячи задач

Asyncio — **однопоточная** кооперативная многозадачность. Есть один цикл
событий (event loop) и множество корутин. Корутина выполняется, пока сама
не уступит управление через `await` — это ключевое отличие от потоков, где
ОС переключает задачи принудительно в любой момент (вытесняющая
многозадачность).

Следствия:
- нет гонок на `counter += 1` между await-ами: код между await-ами
  исполняется атомарно (переключение — только на await);
- зато «жадная» корутина без await блокирует всё;
- одна корутина может ожидать тысячи сокетов — накладные расходы на задачу
  в разы меньше, чем на поток.

### Ключевые слова и функции

```python
async def fetch(i):           # корутина — «ленивая» функция
    await asyncio.sleep(0.05) # уступает управление на время ожидания
    return i

async def main():
    results = await asyncio.gather(             # запустить все и ждать все
        fetch(1), fetch(2), fetch(3))
    task = asyncio.create_task(fetch(4))        # задача: стартовала сейчас
    r = await task                              # ...а результат ждём тут
```

`asyncio.run(main())` — вход в async-мир из обычного кода (один раз на
программу). `await` можно ставить только внутри `async def`.

### gather и семафор

`gather` запускает все корутины конкурентно. Если задач тысячи, а «сервер»
выдерживает 100 соединений — используем `asyncio.Semaphore`:

```python
sem = asyncio.Semaphore(100)

async def limited(i):
    async with sem:
        return await fetch(i)
```

### Потоки или asyncio?

| | Потоки | asyncio |
|---|---|---|
| Переключение | вытесняющее (ОС) | кооперативное (await) |
| Масштаб задач | десятки–сотни | тысячи и больше |
| Гонки данных | да | только между await-ами |
| CPU-код | бесполезен (GIL) | блокирует всё |
| Блокирующие библиотеки | подходят | блокируют цикл (!) |

Критерий: много I/O + нужно много одновременных задач → asyncio.
CPU-работа → процессы (лаба 4). Смешанная → комбинировать.

### Чем опасна блокирующая функция в async-коде

`time.sleep(0.05)` (не `asyncio.sleep`) внутри корутины останавливает ВЕСЬ
цикл событий: ни одна другая корутина не выполняется. В работе это
демонстрируется явно.

## Задание

Заполните `solution.py` (все функции `async`, кроме `main`):

1. **`fetch_async(item, delay)`** — корутина: `await asyncio.sleep(delay)`,
   вернуть `(item, item * item)`.
2. **`fetch_all_async(items, delay)`** — конкурентно все items запросов
   через `asyncio.gather`. Вернуть `(результаты, сек)`, упорядочены по item.
3. **`fetch_all_limited(items, delay, max_concurrent)`** — то же, но
   не более max_concurrent одновременно (`asyncio.Semaphore`).
4. **`measure_blocking_mistake(items, delay)`** — «ошибка новичка»:
   корутина использует `time.sleep(delay)` вместо `asyncio.sleep`.
   Вернуть время выполнения: оно окажется ≈ items × delay — блокирующий
   сон парализует цикл событий.
5. **`main()`** — все пункты + сравнение с потоками (лаба 2).

### Ожидаемые результаты

- `fetch_all_async(96, 0.05)` ≈ 0.05–0.1 c — все запросы «одновременно».
- `fetch_all_limited(96, 0.05, 8)` ≈ 0.6 c.
- `measure_blocking_mistake(96, 0.05)` ≈ 4.8 c — блокирующий sleep убил
  конкурентность.

## Контрольные вопросы

1. Чем кооперативная многозадачность отличается от вытесняющей?
2. Почему между двумя `await` корутина «владеет» данными без Lock?
3. Что случится, если в корутине вызвать `time.sleep(10)`? Проверьте.
4. Когда выбрали бы потоки, а когда asyncio? Приведите по примеру.
5. Что делает `asyncio.gather` и чем отличается от последовательных `await`?

## Что сдаётся

`solution.py` + отчёт: таблица сравнения (последовательно/потоки/async/
async+лимит/ошибка с time.sleep), анализ, ответы на вопросы.

## Критерии оценки

| Пункт | Баллы |
|---|---|
| fetch_all_async: время ≈ delay, результаты упорядочены | 2 |
| fetch_all_limited: лимит соблюдается | 2 |
| measure_blocking_mistake: продемонстрирована деградация | 2 |
| Сравнительная таблица в отчёте | 2 |
| Ответы на контрольные вопросы | 2 |

## Типичные ошибки

- `await` вне `async def` — SyntaxError.
- Забыт `await` перед корутиной: `RuntimeWarning: never awaited`, ничего
  не выполняется.
- `asyncio.run()` внутри работающего цикла (Jupyter) — RuntimeError.
- `time.sleep` в корутине — «секретный» последовательный режим (это п.4
  работы, тут это фича).