Паралелізм (2 ядра):
 Ядро 1: ████████████████████████ → Задача A виконана
 Ядро 2: ████████████████████████ → Задача B виконана
 Час:    ════════════════════════ (1 одиниця часу для обох)

Конкурентність (1 ядро, чергування):
 Ядро 1: ████░░░░████░░░░████░░░░ → Задача A (виконується по частинах)
 Ядро 1: ░░░░████░░░░████░░░░████ → Задача B (в паузах A)
 Час:    ════════════════════════ (2 одиниці часу для обох, але "одночасно")

Однопотоковий HTTP-клієнт (послідовно):
 [Запит 1] ───wait 100ms───► [Отримано]
                              [Запит 2] ───wait 100ms───► [Отримано]
                                                           [Запит 3] ───wait...
 Загальний час: 300ms+

Конкурентний HTTP-клієнт (asyncio або threading):
 [Запит 1] ──────wait 100ms──────► [Отримано]
 [Запит 2] ──────wait 100ms──────► [Отримано]
 [Запит 3] ──────wait 100ms──────► [Отримано]
 Загальний час: ~100ms  ← всі три чекають "одночасно"

# io_vs_cpu_test.py
import time
import urllib.request


# === Тест I/O-bound ===
def io_bound_task():
    """Завантажуємо сторінку — майже весь час очікуємо відповіді сервера."""
    start = time.perf_counter()
    with urllib.request.urlopen("https://httpbin.org/delay/1") as resp:
        data = resp.read()
    elapsed = time.perf_counter() - start
    print(f"I/O-bound: {elapsed:.2f}s, отримано {len(data)} байт")


# === Тест CPU-bound ===
def cpu_bound_task(n: int = 10_000_000) -> int:
    """Рахуємо суму — процесор постійно зайнятий, жодного очікування."""
    start = time.perf_counter()
    result = sum(i * i for i in range(n))
    elapsed = time.perf_counter() - start
    print(f"CPU-bound: {elapsed:.2f}s, результат {result}")
    return result

# reference_counting_demo.py
import sys

a = [1, 2, 3]    # список створено, refcount = 1
b = a            # refcount = 2
c = a            # refcount = 3

print(sys.getrefcount(a))  # 4 (getrefcount сам додає +1 тимчасово)

del b            # refcount = 3
del c            # refcount = 2
# Коли 'a' вийде зі scope → refcount = 0 → пам'ять звільнена автоматично

import sys

# Поточний інтервал перемикання (у секундах)
print(sys.getswitchinterval())  # 0.005 (5 мілісекунд за замовчуванням)

# Можна змінити (зазвичай не потрібно):
sys.setswitchinterval(0.001)  # перемикати кожну мілісекунду

Потік 1: [Python код]──GIL──[socket.recv() → звільнює GIL]──────────────────[GIL повернуто]──[обробка]
Потік 2:               (чекає GIL)                          [отримує GIL]──[виконує код]──[звільняє GIL]

# gil_benchmark.py
import threading
import time
from concurrent.futures import ThreadPoolExecutor
import urllib.request


# ── CPU-bound задача (страждає від GIL) ──────────────────────────────────────

def count(n: int = 50_000_000) -> int:
    """Чиста обчислювальна задача без I/O."""
    return sum(range(n))


def benchmark_cpu() -> None:
    n = 50_000_000

    # Однопотоково
    t0 = time.perf_counter()
    count(n)
    count(n)
    single_time = time.perf_counter() - t0

    # Два потоки паралельно (через threading)
    t0 = time.perf_counter()
    t1 = threading.Thread(target=count, args=(n,))
    t2 = threading.Thread(target=count, args=(n,))
    t1.start(); t2.start()
    t1.join();  t2.join()
    thread_time = time.perf_counter() - t0

    print("=== CPU-bound ===")
    print(f"  Однопотоково:   {single_time:.2f}s")
    print(f"  Два потоки:     {thread_time:.2f}s  ← майже те саме або повільніше!")
    print(f"  Прискорення:    {single_time / thread_time:.2f}x  (очікувалось ~2x)")


# ── I/O-bound задача (GIL не заважає) ────────────────────────────────────────

URLS = [
    "https://httpbin.org/delay/0.5",
    "https://httpbin.org/delay/0.5",
    "https://httpbin.org/delay/0.5",
    "https://httpbin.org/delay/0.5",
]


def fetch(url: str) -> int:
    with urllib.request.urlopen(url, timeout=10) as resp:
        return len(resp.read())


def benchmark_io() -> None:
    # Послідовно
    t0 = time.perf_counter()
    for url in URLS:
        fetch(url)
    sequential_time = time.perf_counter() - t0

    # Паралельно через потоки
    t0 = time.perf_counter()
    with ThreadPoolExecutor(max_workers=4) as pool:
        list(pool.map(fetch, URLS))
    thread_time = time.perf_counter() - t0

    print("\n=== I/O-bound ===")
    print(f"  Послідовно:   {sequential_time:.2f}s")
    print(f"  Чотири потоки:{thread_time:.2f}s  ← ~4x швидше!")
    print(f"  Прискорення:  {sequential_time / thread_time:.2f}x")


benchmark_cpu()
# benchmark_io()  # Розкоментуйте для перевірки (потрібен інтернет)

Модель threading:

 Процес Python (1 GIL)
 ┌─────────────────────────────────────────────┐
 │  Потік 1  Потік 2  Потік 3                  │
 │  [код]    [код]    [код]                    │
 │     ↕        ↕        ↕      ← перемикання │
 │  GIL: тільки один активний у момент часу    │
 │  Спільна пам'ять: так (але треба синхронізація) │
 └─────────────────────────────────────────────┘

Модель multiprocessing:

 Процес 1 (GIL₁)    Процес 2 (GIL₂)    Процес 3 (GIL₃)
 ┌──────────────┐    ┌──────────────┐    ┌──────────────┐
 │  [Python код]│    │  [Python код]│    │  [Python код]│
 │  Ядро 1      │    │  Ядро 2      │    │  Ядро 3      │
 └──────────────┘    └──────────────┘    └──────────────┘
       ↑                   ↑                   ↑
  Окрема пам'ять      Окрема пам'ять      Окрема пам'ять
  (дані копіюються між процесами через серіалізацію)

Модель asyncio:

 Один процес, один потік, один GIL
 ┌──────────────────────────────────────────────────┐
 │  Event Loop                                       │
 │  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐            │
 │  │Task 1│ │Task 2│ │Task 3│ │Task 4│  ← черга   │
 │  └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘            │
 │     │await   │await   │await   │await            │
 │     └────────┴────────┴────────┘                 │
 │  Поки Task 1 чекає → event loop запускає Task 2  │
 └──────────────────────────────────────────────────┘

Задача CPU-bound? (обчислення, без очікування)
    → так → multiprocessing (ProcessPoolExecutor)
    → ні  → задача I/O-bound

Задача I/O-bound і...
    → дуже багато конкурентних операцій (>1000)? → asyncio
    → потрібна інтеграція з синхронними бібліотеками? → threading (ThreadPoolExecutor)
    → простий скрипт з кількома паралельними запитами? → threading (ThreadPoolExecutor)
    → бібліотека вже асинхронна (aiohttp, asyncpg)? → asyncio

# concurrency_benchmark.py
import asyncio
import time
import urllib.request
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from typing import Callable


URLS = [f"https://httpbin.org/delay/0.3" for _ in range(20)]


# ── Послідовний (baseline) ────────────────────────────────────────────────────
def fetch_sync(url: str) -> int:
    with urllib.request.urlopen(url, timeout=15) as r:
        return len(r.read())


def run_sequential() -> None:
    t = time.perf_counter()
    results = [fetch_sync(u) for u in URLS]
    print(f"Sequential:    {time.perf_counter() - t:.2f}s  ({sum(results)} байт)")


# ── Threading ─────────────────────────────────────────────────────────────────
def run_threading() -> None:
    t = time.perf_counter()
    with ThreadPoolExecutor(max_workers=20) as pool:
        results = list(pool.map(fetch_sync, URLS))
    print(f"Threading:     {time.perf_counter() - t:.2f}s  ({sum(results)} байт)")


# ── asyncio ───────────────────────────────────────────────────────────────────
async def fetch_async(url: str, session) -> int:
    # Використовуємо run_in_executor для urllib (синхронна), щоб не встановлювати aiohttp
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, fetch_sync, url)
    return result


async def run_asyncio_impl() -> None:
    t = time.perf_counter()
    tasks = [fetch_async(u, None) for u in URLS]
    results = await asyncio.gather(*tasks)
    print(f"asyncio:       {time.perf_counter() - t:.2f}s  ({sum(results)} байт)")


def run_asyncio() -> None:
    asyncio.run(run_asyncio_impl())


# ── Запуск ───────────────────────────────────────────────────────────────────
if __name__ == "__main__":
    print(f"Завантажуємо {len(URLS)} URL по ~0.3s кожен\n")
    run_sequential()   # ~6s
    run_threading()    # ~0.3-0.5s
    run_asyncio()      # ~0.3-0.5s