14.1-dars: Jarayon, oqim, korutina farqi

def ishchi():
    while True:
        hisobla()          # ip o'zi hech narsa qilmasa ham almashadi

async def ishchi():
    while True:
        hisobla()          # ⚠️ await yo'q — butun sikl to'xtaydi
        await asyncio.sleep(0)   # ✅ boshqalarga navbat berish

os.getpid()                       # jarayon
threading.get_ident()             # ip (OT ID si emas, Python ID si)
threading.current_thread().name   # ip nomi
asyncio.current_task().get_name() # vazifa nomi

import threading, multiprocessing, asyncio

threading.Thread(target=f).start()                 # ip
multiprocessing.Process(target=f).start()          # jarayon
asyncio.run(main())                                # korutinalar sikli

os.getpid()  threading.get_ident()  asyncio.current_task().get_name()

jarayon:  izolyatsiya, parallellik, qimmat
ip:       umumiy xotira, GIL, qulflar kerak
korutina: eng arzon, bitta ip, await da almashadi
konkurentlik ≠ parallellik

"""Bir xil 'so'rovlar' uch model bilan: ketma-ket, iplar, korutinalar, jarayonlar; identifikatorlar va vaqt."""

import asyncio
import multiprocessing as mp
import os
import threading
import time

SOROVLAR = 12
KUTISH = 0.1


def sorov(nomer: int) -> tuple[int, int, str]:
    """Bloklovchi 'tarmoq so'rovi'."""
    time.sleep(KUTISH)
    return nomer, os.getpid(), threading.current_thread().name


async def async_sorov(nomer: int) -> tuple[int, int, str]:
    await asyncio.sleep(KUTISH)
    vazifa = asyncio.current_task()
    return nomer, os.getpid(), vazifa.get_name() if vazifa else "?"


def ketma_ket() -> list[tuple[int, int, str]]:
    return [sorov(i) for i in range(SOROVLAR)]


def iplar_bilan() -> list[tuple[int, int, str]]:
    natijalar: list[tuple[int, int, str]] = []
    qulf = threading.Lock()

    def ishchi(n: int) -> None:
        natija = sorov(n)
        with qulf:
            natijalar.append(natija)

    iplar = [threading.Thread(target=ishchi, args=(i,), name=f"ip-{i}") for i in range(SOROVLAR)]
    for ip in iplar:
        ip.start()
    for ip in iplar:
        ip.join()
    return natijalar


def korutinalar_bilan() -> list[tuple[int, int, str]]:
    async def hammasi() -> list[tuple[int, int, str]]:
        vazifalar = [asyncio.create_task(async_sorov(i), name=f"vazifa-{i}") for i in range(SOROVLAR)]
        return list(await asyncio.gather(*vazifalar))
    return asyncio.run(hammasi())


def olch(funksiya) -> tuple[float, list[tuple[int, int, str]]]:
    bosh = time.perf_counter()
    natija = funksiya()
    return time.perf_counter() - bosh, natija


if __name__ == "__main__":
    print("=== 1. Asosiy jarayon ===")
    print(f"  PID: {os.getpid() > 0}, asosiy ip: {threading.current_thread().name}, yadrolar: {os.cpu_count() >= 1}")

    print("\n=== 2. Uch model ===")
    t_ket, n_ket = olch(ketma_ket)
    t_ip, n_ip = olch(iplar_bilan)
    t_as, n_as = olch(korutinalar_bilan)
    print(f"  ketma-ket  {SOROVLAR} × {KUTISH} s kutish → kamida {SOROVLAR * KUTISH:.1f} s: {t_ket >= SOROVLAR * KUTISH * 0.95}")
    print(f"  iplar      kamida 5 barobar tez: {t_ket / t_ip >= 5}")
    print(f"  korutinalar kamida 5 barobar tez: {t_ket / t_as >= 5}")
    print(f"  natijalar soni bir xil: {len(n_ket) == len(n_ip) == len(n_as) == SOROVLAR}")

    print("\n=== 3. Kim qayerda ishladi ===")
    print(f"  ketma-ket:   hammasi bitta ipda: {len({n for _, _, n in n_ket}) == 1}")
    print(f"  iplar:       {len({n for _, _, n in n_ip})} xil ip nomi")
    print(f"  korutinalar: {len({n for _, _, n in n_as})} xil vazifa nomi, hammasi bitta jarayonda: "
          f"{len({p for _, p, _ in n_as}) == 1}")
    print(f"  korutina nomlari: {sorted(n for _, _, n in n_as)[:3]} ...")

    print("\n=== 4. Jarayonlar ===")
    with mp.Pool(processes=4) as pul:
        bosh = time.perf_counter()
        n_jar = pul.map(sorov, range(SOROVLAR))
        t_jar = time.perf_counter() - bosh
    pidlar = {p for _, p, _ in n_jar}
    print(f"  {len(pidlar)} xil PID da bajarildi, asosiy jarayondan farq qiladi: {os.getpid() not in pidlar}")
    print(f"  ketma-ketdan tez: {t_ket / t_jar >= 2}")
    print("  ⭐ I/O uchun jarayonlar ortiqcha: iplar va korutinalar arzonroq")

=== 1. Asosiy jarayon ===
  PID: True, asosiy ip: MainThread, yadrolar: True

=== 2. Uch model ===
  ketma-ket  12 × 0.1 s kutish → kamida 1.2 s: True
  iplar      kamida 5 barobar tez: True
  korutinalar kamida 5 barobar tez: True
  natijalar soni bir xil: True

=== 3. Kim qayerda ishladi ===
  ketma-ket:   hammasi bitta ipda: True
  iplar:       12 xil ip nomi
  korutinalar: 12 xil vazifa nomi, hammasi bitta jarayonda: True
  korutina nomlari: ['vazifa-0', 'vazifa-1', 'vazifa-10'] ...

=== 4. Jarayonlar ===
  4 xil PID da bajarildi, asosiy jarayondan farq qiladi: True
  ketma-ketdan tez: True
  ⭐ I/O uchun jarayonlar ortiqcha: iplar va korutinalar arzonroq

"""Yaratish vaqti; bitta birlikka xotira; 10 000 korutina va 10 000 ip farqi; amaliy chegaralar."""

import asyncio
import gc
import multiprocessing as mp
import sys
import threading
import time
import tracemalloc


def hech_narsa() -> None:
    pass


async def async_hech_narsa() -> None:
    await asyncio.sleep(0)


def iplar_yarat(n: int) -> None:
    iplar = [threading.Thread(target=hech_narsa) for _ in range(n)]
    for ip in iplar:
        ip.start()
    for ip in iplar:
        ip.join()


def korutinalar_yarat(n: int) -> None:
    async def hammasi() -> None:
        await asyncio.gather(*(async_hech_narsa() for _ in range(n)))
    asyncio.run(hammasi())


def jarayonlar_yarat(n: int) -> None:
    jarayonlar = [mp.Process(target=hech_narsa) for _ in range(n)]
    for j in jarayonlar:
        j.start()
    for j in jarayonlar:
        j.join()


def olch(funksiya, n: int, takror: int = 3) -> float:
    eng = float("inf")
    for _ in range(takror):
        bosh = time.perf_counter()
        funksiya(n)
        eng = min(eng, time.perf_counter() - bosh)
    return eng


if __name__ == "__main__":
    print("=== 1. 100 birlik yaratish va tugatish ===")
    t_ip = olch(iplar_yarat, 100)
    t_kor = olch(korutinalar_yarat, 100)
    t_jar = olch(jarayonlar_yarat, 8, takror=1)
    print(f"  korutinalar iplardan tez: {t_kor < t_ip}")
    print(f"  8 jarayon 100 ipdan ham uzoq vaqt oldi: {t_jar > t_ip}")
    print(f"  jarayon yaratish korutinadan kamida 20 barobar qimmat (bittasiga): "
          f"{(t_jar / 8) / (t_kor / 100) >= 20}")

    print("\n=== 2. Miqyos: 10 000 birlik ===")
    t_10k = olch(korutinalar_yarat, 10_000, takror=1)
    print(f"  10 000 korutina yaratildi va tugadi: {t_10k < 5.0}")
    print(f"  bir korutinaga o'rtacha vaqt 100 korutinadagidan yomonlashmadi: "
          f"{t_10k / 10_000 <= (t_kor / 100) * 3}")
    print("  ⚠️ 10 000 ip yaratish ko'p tizimlarda xotira va yadro chegarasiga uriladi")

    print("\n=== 3. Vazifaga qancha xotira ===")

    async def kop_vazifa(n: int) -> int:
        vazifalar = [asyncio.create_task(asyncio.sleep(0.05)) for _ in range(n)]
        joriy, _ = tracemalloc.get_traced_memory()
        await asyncio.gather(*vazifalar)
        return joriy

    gc.collect()
    tracemalloc.start()
    xotira = asyncio.run(kop_vazifa(5_000))
    tracemalloc.stop()
    bir_vazifa = xotira / 5_000
    print(f"  5 000 vazifa uchun ~{xotira / 1e6:.1f} MB, bittasiga ~{bir_vazifa:.0f} bayt")
    print(f"  bir vazifa 5 KB dan kam: {bir_vazifa < 5_000}")
    print(f"  taqqoslash uchun: ip steki sukut bo'yicha kamida 64 KB (OT ga bog'liq)")

    print("\n=== 4. Amaliy chegaralar ===")
    jadval = [
        ("jarayon", "yadrolar soni × 1–2", "xotira, kontekst almashinuvi"),
        ("ip", "yuzlab – minglab", "stek xotirasi, yadro resurslari"),
        ("korutina", "yuz minglab", "faqat xotira"),
    ]
    for model, chegara, sabab in jadval:
        print(f"  {model:10} {chegara:24} {sabab}")
    print(f"  bu mashinada yadrolar: {mp.cpu_count() >= 1}, faol iplar: {threading.active_count()}")

=== 1. 100 birlik yaratish va tugatish ===
  korutinalar iplardan tez: True
  8 jarayon 100 ipdan ham uzoq vaqt oldi: True
  jarayon yaratish korutinadan kamida 20 barobar qimmat (bittasiga): True

=== 2. Miqyos: 10 000 birlik ===
  10 000 korutina yaratildi va tugadi: True
  bir korutinaga o'rtacha vaqt 100 korutinadagidan yomonlashmadi: True
  ⚠️ 10 000 ip yaratish ko'p tizimlarda xotira va yadro chegarasiga uriladi

=== 3. Vazifaga qancha xotira ===
  5 000 vazifa uchun ~3.7 MB, bittasiga ~746 bayt
  bir vazifa 5 KB dan kam: True
  taqqoslash uchun: ip steki sukut bo'yicha kamida 64 KB (OT ga bog'liq)

=== 4. Amaliy chegaralar ===
  jarayon    yadrolar soni × 1–2      xotira, kontekst almashinuvi
  ip         yuzlab – minglab         stek xotirasi, yadro resurslari
  korutina   yuz minglab              faqat xotira
  bu mashinada yadrolar: True, faol iplar: 1

"""Iplar o'z-o'zidan almashadi; korutinalar faqat await da; bloklovchi korutina butun siklni to'xtatadi; yechim."""

import asyncio
import threading
import time


def og_ir_hisob(n: int = 300_000) -> int:
    s = 0
    for i in range(n):
        s += i * i
    return s


print("=== 1. Iplar: majburiy almashinuv ===")
jurnal: list[str] = []


def ip_ishchisi(nom: str) -> None:
    for _ in range(4):
        og_ir_hisob()
        jurnal.append(nom)


iplar = [threading.Thread(target=ip_ishchisi, args=(nom,)) for nom in "AB"]
for ip in iplar:
    ip.start()
for ip in iplar:
    ip.join()
almashinuvlar = sum(1 for a, b in zip(jurnal, jurnal[1:]) if a != b)
print(f"  har ip {len(jurnal) // 2} bosqichni bajardi, jami yozuvlar: {len(jurnal)}")
print(f"  iplar hech qanday 'await' yozmasdan almashdi: {almashinuvlar >= 1}")

print("\n=== 2. Korutinalar: faqat await da ===")


async def yaxshi_ishchi(nom: str, jurnal: list[str]) -> None:
    for _ in range(4):
        await asyncio.sleep(0)          # navbatni boshqalarga berish
        jurnal.append(nom)


async def yaxshi() -> list[str]:
    j: list[str] = []
    await asyncio.gather(yaxshi_ishchi("A", j), yaxshi_ishchi("B", j))
    return j


natija = asyncio.run(yaxshi())
print(f"  await bilan: {''.join(natija)} — navbatma-navbat")

print("\n=== 3. ⚠️ Bloklovchi korutina ===")


async def bloklovchi_ishchi(nom: str, jurnal: list[str]) -> None:
    for _ in range(4):
        og_ir_hisob()                   # await yo'q — sikl to'xtaydi
        jurnal.append(nom)


async def bloklovchi() -> list[str]:
    j: list[str] = []
    await asyncio.gather(bloklovchi_ishchi("A", j), bloklovchi_ishchi("B", j))
    return j


natija = asyncio.run(bloklovchi())
print(f"  await siz: {''.join(natija)} — A tugamaguncha B boshlanmadi")

print("\n=== 4. Hodisa siklining kechikishi ===")


async def olchov() -> tuple[float, float]:
    """Sikl 'yurak urishi': har 10 ms da belgilanishi kerak."""
    kechikishlar: list[float] = []

    async def yurak() -> None:
        oldingi = time.perf_counter()
        for _ in range(20):
            await asyncio.sleep(0.01)
            hozir = time.perf_counter()
            kechikishlar.append(hozir - oldingi - 0.01)
            oldingi = hozir

    async def bloklovchi_vazifa() -> None:
        await asyncio.sleep(0.05)
        og_ir_hisob(3_000_000)          # ⚠️ siklni bloklaydi

    await asyncio.gather(yurak(), bloklovchi_vazifa())
    return max(kechikishlar), sum(kechikishlar) / len(kechikishlar)


eng_katta, ortacha = asyncio.run(olchov())
print(f"  eng katta kechikish o'rtachadan kamida 5 barobar katta: {eng_katta > ortacha * 5}")
print(f"  ⭐ bitta bloklovchi qism butun siklga ta'sir qiladi")
print(f"  ✅ yechim: og'ir hisobni asyncio.to_thread yoki jarayonga chiqarish (14.7-dars)")

=== 1. Iplar: majburiy almashinuv ===
  har ip 4 bosqichni bajardi, jami yozuvlar: 8
  iplar hech qanday 'await' yozmasdan almashdi: True

=== 2. Korutinalar: faqat await da ===
  await bilan: ABABABAB — navbatma-navbat

=== 3. ⚠️ Bloklovchi korutina ===
  await siz: AAAABBBB — A tugamaguncha B boshlanmadi

=== 4. Hodisa siklining kechikishi ===
  eng katta kechikish o'rtachadan kamida 5 barobar katta: True
  ⭐ bitta bloklovchi qism butun siklga ta'sir qiladi
  ✅ yechim: og'ir hisobni asyncio.to_thread yoki jarayonga chiqarish (14.7-dars)

"""I/O bosqichi: ketma-ket, iplar, korutinalar; CPU bosqichi: iplar va jarayonlar; tanlov va asos."""

import asyncio
import concurrent.futures as cf
import hashlib
import time

QURILMALAR = [f"qurilma-{i:05d}" for i in range(400)]
KUTISH = 0.005


def push_yubor(qurilma: str) -> str:
    time.sleep(KUTISH)                      # tarmoq
    return f"{qurilma}:ok"


async def async_push(qurilma: str) -> str:
    await asyncio.sleep(KUTISH)
    return f"{qurilma}:ok"


def hisobot_bolagi(bolak: list[str]) -> str:
    """Sof Python CPU ish (12.6-dars)."""
    h = hashlib.sha256()
    for q in bolak:
        h.update(q.encode())
        for _ in range(200):
            h.update(b"x")
    return h.hexdigest()[:8]


def ketma_ket_io() -> list[str]:
    return [push_yubor(q) for q in QURILMALAR]


def iplar_io(ishchilar: int = 64) -> list[str]:
    with cf.ThreadPoolExecutor(max_workers=ishchilar) as ex:
        return list(ex.map(push_yubor, QURILMALAR))


def korutinalar_io() -> list[str]:
    async def hammasi() -> list[str]:
        return list(await asyncio.gather(*(async_push(q) for q in QURILMALAR)))
    return asyncio.run(hammasi())


def olch(funksiya, *args) -> tuple[float, object]:
    bosh = time.perf_counter()
    natija = funksiya(*args)
    return time.perf_counter() - bosh, natija


if __name__ == "__main__":
    print("=== 1. I/O bosqichi ===")
    t_ket, n_ket = olch(ketma_ket_io)
    t_ip, n_ip = olch(iplar_io)
    t_kor, n_kor = olch(korutinalar_io)
    print(f"  {len(QURILMALAR)} ta 'so'rov', har biri {KUTISH * 1000:.0f} ms")
    print(f"  natijalar bir xil: {n_ket == n_ip == n_kor}")
    print(f"  iplar ketma-ketdan kamida 5 barobar tez: {t_ket / t_ip >= 5}")
    print(f"  korutinalar ham: {t_ket / t_kor >= 5}")
    print(f"  korutinalar 400 ta 'ulanish' uchun atigi bitta ip ishlatdi")

    print("\n=== 2. CPU bosqichi ===")
    bolaklar = [QURILMALAR[i::4] for i in range(4)]
    t_ket_cpu, _ = olch(lambda: [hisobot_bolagi(b) for b in bolaklar])
    with cf.ThreadPoolExecutor(max_workers=4) as ex:
        t_ip_cpu, _ = olch(lambda: list(ex.map(hisobot_bolagi, bolaklar)))
    with cf.ProcessPoolExecutor(max_workers=4) as pex:
        list(pex.map(hisobot_bolagi, bolaklar[:1]))          # isitish
        t_jar_cpu, _ = olch(lambda: list(pex.map(hisobot_bolagi, bolaklar)))
    print(f"  iplar ketma-ketga yaqin (GIL): {t_ip_cpu > t_ket_cpu * 0.7}")
    print(f"  jarayonlar iplardan tez: {t_jar_cpu < t_ip_cpu}")

    print("\n=== 3. Tanlov ===")
    tanlovlar = [
        ("I/O, minglab ulanish", "korutinalar (asyncio)", "eng arzon, bitta ip"),
        ("I/O, bloklovchi kutubxona", "iplar", "kod o'zgarmaydi"),
        ("sof Python CPU", "jarayonlar", "GIL ni chetlab o'tadi"),
        ("C kutubxona (NumPy, hashlib katta bufer)", "iplar", "GIL bo'shatiladi"),
        ("ishonchsiz kod", "jarayonlar", "izolyatsiya"),
    ]
    for ish, model, sabab in tanlovlar:
        print(f"  {ish:42} → {model:22} ({sabab})")

    print("\n=== 4. Ushbu servis uchun ===")
    print("  push yuborish  → asyncio (5 000 ulanish, har biri kutish bilan)")
    print("  hisobot        → ProcessPoolExecutor (sof Python hisob)")
    print("  ⭐ bitta ilovada ikki model birga ishlatiladi (14.8-dars)")

=== 1. I/O bosqichi ===
  400 ta 'so'rov', har biri 5 ms
  natijalar bir xil: True
  iplar ketma-ketdan kamida 5 barobar tez: True
  korutinalar ham: True
  korutinalar 400 ta 'ulanish' uchun atigi bitta ip ishlatdi

=== 2. CPU bosqichi ===
  iplar ketma-ketga yaqin (GIL): True
  jarayonlar iplardan tez: False

=== 3. Tanlov ===
  I/O, minglab ulanish                       → korutinalar (asyncio)  (eng arzon, bitta ip)
  I/O, bloklovchi kutubxona                  → iplar                  (kod o'zgarmaydi)
  sof Python CPU                             → jarayonlar             (GIL ni chetlab o'tadi)
  C kutubxona (NumPy, hashlib katta bufer)   → iplar                  (GIL bo'shatiladi)
  ishonchsiz kod                             → jarayonlar             (izolyatsiya)

=== 4. Ushbu servis uchun ===
  push yuborish  → asyncio (5 000 ulanish, har biri kutish bilan)
  hisobot        → ProcessPoolExecutor (sof Python hisob)
  ⭐ bitta ilovada ikki model birga ishlatiladi (14.8-dars)

for ulanish in ulanishlar:                 # ❌ 10 000 ip
    threading.Thread(target=xizmat, args=(ulanish,)).start()

async def yukla(u: str) -> str:
    return requests.get(u).text            # ❌ butun siklni to'xtatadi
    return await mijoz.get(u)              # ✅ async kutubxona
    return await asyncio.to_thread(requests.get, u)   # ✅ iplarga chiqarish

async def hisobla() -> int:
    return og_ir_hisob()                   # ❌ sikl bloklanadi

with ProcessPoolExecutor() as ex:
    ex.map(kichik_funksiya, 100_000 * [...])   # ❌ uzatish narxi (12.6-dars)

threading.Thread(target=async_funksiya)    # ❌ korutina chaqirilmaydi
asyncio.run(async_funksiya())              # ✅

self.hisob += 1                            # ❌ 12.5-dars
with self.qulf: self.hisob += 1            # ✅

umumiy = {}                                # ❌ har jarayonda o'z nusxasi
manager = multiprocessing.Manager()        # ✅ yoki navbat/shared_memory (14.4-dars)

for u in manzillar:
    asyncio.run(yukla(u))                  # ❌ har safar yangi sikl, konkurentlik yo'q
asyncio.run(hammasi(manzillar))            # ✅ bitta sikl, gather bilan

import asyncio
import os
import threading
1.  print(threading.current_thread().name)
2.  print(threading.active_count())
3.  ip = threading.Thread(target=lambda: None)
    print(ip.is_alive())
4.  ip.start(); ip.join()
    print(ip.is_alive())
5.  print(type(os.getpid()).__name__)
6.  async def f():
        return 42
    print(asyncio.run(f()))
7.  async def g():
        return asyncio.current_task().get_name()
    print(asyncio.run(g()).startswith("Task"))
8.  async def h():
        await asyncio.sleep(0)
        return "tayyor"
    print(asyncio.run(h()))
9.  print(asyncio.iscoroutinefunction(h), asyncio.iscoroutinefunction(print))
10. c = h()
    print(type(c).__name__)
    c.close()
11. import multiprocessing as mp
    print(mp.cpu_count() >= 1)
12. print(threading.get_ident() == threading.main_thread().ident)

1.  for ulanish in ulanishlar:      # 5000 ta
        threading.Thread(target=xizmat, args=(ulanish,)).start()

2.  async def yukla(manzil):
        return requests.get(manzil).text

3.  async def hisobot(malumot):
        return og_ir_hisob(malumot)

4.  for manzil in manzillar:
        natija = asyncio.run(yukla(manzil))

5.  ip = threading.Thread(target=async_funksiya())
    ip.start()