Init

lab06_asyncio/examples/01_async_basics_demo.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""Демо: asyncio — конкурентность на одном потоке.
+
+Запуск из корня курса:
+    python lab06_asyncio/examples/01_async_basics_demo.py
+
+Три корутины «ждут сеть» одновременно: 0.6 c ожидания занимают 0.3 c.
+Всё на одном потоке — переключения только на await.
+"""
+import asyncio
+import time
+
+
+async def fetch(name: str, delay: float) -> str:
+    print(f"  {name}: старт")
+    await asyncio.sleep(delay)          # «ожидание сети» — уступает циклу
+    print(f"  {name}: готов")
+    return name
+
+
+async def main():
+    print("--- gather: три корутины конкурентно ---")
+    t0 = time.perf_counter()
+    results = await asyncio.gather(
+        fetch("A", 0.3),
+        fetch("B", 0.2),
+        fetch("C", 0.1),
+    )
+    print(f"результаты: {results}")
+    print(f"время: {time.perf_counter() - t0:.2f} c "
+          f"(сумма ожиданий 0.6 c)\n")
+
+    print("--- create_task: запустить сейчас, ждать позже ---")
+    t0 = time.perf_counter()
+    task = asyncio.create_task(fetch("фоновая", 0.3))
+    await asyncio.sleep(0.1)            # пока она ждёт — занимаемся своим
+    print("  главное: что-то делаю, пока фоновая ждёт")
+    await task
+    print(f"время: {time.perf_counter() - t0:.2f} c (задачи шли вместе)")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

lab06_asyncio/examples/02_blocking_mistake_demo.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""Демо: блокирующий сон убивает event loop.
+
+Запуск из корня курса:
+    python lab06_asyncio/examples/02_blocking_mistake_demo.py
+
+time.sleep (в отличие от asyncio.sleep) НЕ уступает управление:
+все корутины встают в очередь. Классическая ошибка в async-коде.
+"""
+import asyncio
+import time
+
+
+async def worker_async(name: str, delay: float) -> str:
+    await asyncio.sleep(delay)      # уступает: другие работают
+    return name
+
+
+async def worker_blocking(name: str, delay: float) -> str:
+    time.sleep(delay)               # НЕ уступает: парализует loop
+    return name
+
+
+async def run_all(worker, delay: float) -> float:
+    t0 = time.perf_counter()
+    await asyncio.gather(*(worker(f"w{i}", delay) for i in range(5)))
+    return time.perf_counter() - t0
+
+
+async def main():
+    t = await run_all(worker_async, 0.2)
+    print(f"asyncio.sleep: 5 задач за {t:.2f} c (идеал ≈ 0.2 c)")
+
+    t = await run_all(worker_blocking, 0.2)
+    print(f"time.sleep:    5 задач за {t:.2f} c (последовательные 1.0 c!)")
+    print("\nВывод: в корутине можно вызывать только неблокирующие версии")
+    print("операций. time.sleep -> asyncio.sleep, requests -> aiohttp и т.д.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

lab06_asyncio/examples/03_semaphore_demo.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""Демо: asyncio.Semaphore — ограничение конкурентности.
+
+Запуск из корня курса:
+    python lab06_asyncio/examples/03_semaphore_demo.py
+
+50 «запросов», сервер выдерживает 5 одновременных. Семафор не даёт
+превысить лимит: время ≈ 50/5 × delay.
+"""
+import asyncio
+import time
+
+
+async def request(i: int, delay: float) -> int:
+    await asyncio.sleep(delay)
+    return i
+
+
+async def bounded(i: int, delay: float, sem: asyncio.Semaphore) -> int:
+    async with sem:                 # только 5 корутин внутри одновременно
+        return await request(i, delay)
+
+
+async def main():
+    N, DELAY, LIMIT = 50, 0.05, 5
+    sem = asyncio.Semaphore(LIMIT)
+
+    t0 = time.perf_counter()
+    results = await asyncio.gather(*(bounded(i, DELAY, sem)
+                                     for i in range(N)))
+    dt = time.perf_counter() - t0
+    print(f"{N} запросов, лимит {LIMIT}: {dt:.2f} c")
+    print(f"идеал ≈ {N / LIMIT * DELAY:.2f} c")
+    print(f"результаты упорядочены: {results == list(range(N))}")
+    print("\nБез семафора было бы ≈ 0.05 c (все сразу) — но так сервер ляжет.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

lab06_asyncio/solution.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+"""Лабораторная работа 6: асинхронный код (asyncio).
+
+Заполните функции ниже. ИНТЕРФЕЙСЫ МЕНЯТЬ НЕЛЬЗЯ — по ним работают
+автотесты (tests/test_lab06.py).
+
+Запуск из корня курса:
+    python lab06_asyncio/solution.py
+"""
+import asyncio
+import os
+import sys
+import time
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from common.benchmark import make_table
+from common.tasks import get_variant
+
+# TODO: впишите свой номер в журнале (1..20)
+VARIANT_NUMBER = 0
+
+
+async def fetch_async(item: int, delay: float):
+    """Корутина: имитация I/O-запроса.
+
+    await asyncio.sleep(delay) — НЕ блокирует цикл событий.
+    Вернуть (item, item * item).
+    """
+    # TODO: asyncio.sleep + вернуть результат
+    raise NotImplementedError
+
+
+async def fetch_all_async(items: int, delay: float):
+    """Все items запросов конкурентно через asyncio.gather.
+
+    Вернуть (список результатов, elapsed_seconds), упорядочен по item.
+    """
+    # TODO: gather по всем item -> сортировка не нужна, gather сохраняет порядок
+    raise NotImplementedError
+
+
+async def fetch_all_limited(items: int, delay: float, max_concurrent: int):
+    """То же, но не более max_concurrent одновременно (asyncio.Semaphore).
+
+    Вернуть (список результатов, elapsed_seconds), упорядочен по item.
+    """
+    # TODO: sem = asyncio.Semaphore(...); async with sem: await fetch_async(...)
+    raise NotImplementedError
+
+
+async def _fetch_blocking(item: int, delay: float):
+    """«Ошибка новичка»: блокирующий time.sleep внутри корутины.
+
+    time.sleep НЕ уступает управление — парализует весь event loop.
+    """
+    time.sleep(delay)
+    return (item, item * item)
+
+
+async def _blocking_mistake(items: int, delay: float):
+    """Все запросы через gather, но с блокирующим сном. Вернуть секунды."""
+    # TODO: gather по _fetch_blocking, вернуть время
+    raise NotImplementedError
+
+
+def measure_blocking_mistake(items: int, delay: float) -> float:
+    """Обёртка для тестов: asyncio.run + return секунд."""
+    # TODO: return asyncio.run(_blocking_mistake(items, delay))
+    raise NotImplementedError
+
+
+def main():
+    v = get_variant(VARIANT_NUMBER)
+    items, delay = v["io"]["items"], v["io"]["delay"]
+    print(f"Вариант {v['variant']}: I/O-нагрузка {items} запросов по {delay} c\n")
+
+    # --- 1. Async: все запросы сразу ---------------------------------------
+    t0 = time.perf_counter()
+    results, t_async = asyncio.run(fetch_all_async(items, delay))
+    print(f"async, без лимита:        {t_async:.3f} c "
+          f"(упорядочено: {[r[0] for r in results] == list(range(items))})")
+
+    # --- 2. Async с лимитом --------------------------------------------------
+    for mc in (4, 8):
+        res, t_lim = asyncio.run(fetch_all_limited(items, delay, mc))
+        print(f"async, лимит {mc}:        {t_lim:.3f} c "
+              f"(идеал ≈ {items / mc * delay:.2f} c)")
+
+    # --- 3. Ошибка: time.sleep в корутине -----------------------------------
+    t_block = measure_blocking_mistake(items, delay)
+    print(f"async + time.sleep (ошибка!): {t_block:.3f} c "
+          f"≈ последовательные {items * delay:.2f} c\n")
+
+    # --- 4. Сравнение с потоками (лаба 2) ------------------------------------
+    from concurrent.futures import ThreadPoolExecutor
+    from common.tasks import io_fetch
+
+    t0 = time.perf_counter()
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        list(pool.map(io_fetch, range(items), [delay] * items))
+    t_threads = time.perf_counter() - t0
+
+    rows = [("async без лимита", t_async),
+            ("async, лимит 8", t_lim),
+            ("потоки, p=8", t_threads),
+            ("последовательно (ошибка time.sleep)", t_block)]
+    print(make_table(rows, title="Сравнение подходов к I/O"))
+
+    # TODO: в отчёт — таблицу, объяснение разницы потоков и asyncio,
+    # ответ на вопрос «почему time.sleep убил конкурентность».
+
+
+if __name__ == "__main__":
+    main()

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
+  работы, тут это фича).