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())