Init

lab06_asyncio/методичка.md

@@ -0,0 +1,130 @@
+# Лабораторная работа 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
+  работы, тут это фича).