14.3-dars: Race condition, Lock, Queue

def otkaz(a, b, summa):
    a.balans -= summa
    b.balans += summa

qulf = threading.Lock()

with qulf:                 # ✅ har doim with bilan
    hisob.ball += 1

rqulf = threading.RLock()

def tashqi():
    with rqulf:
        ichki()            # ichki() ham with rqulf: ishlatadi — Lock bilan deadlock bo'lardi

ip A: qulf1 olindi → qulf2 kutmoqda
ip B: qulf2 olindi → qulf1 kutmoqda        ← deadlock

navbat: queue.Queue[Vazifa] = queue.Queue(maxsize=100)

navbat.put(vazifa)              # to'lgan bo'lsa — kutadi (orqa bosim)
vazifa = navbat.get()           # bo'sh bo'lsa — kutadi
navbat.task_done()              # bajarildi deb belgilash
navbat.join()                   # hamma vazifa bajarilguncha kutish

import threading, queue

qulf = threading.Lock(); rqulf = threading.RLock()
with qulf: ...                       # har doim with
qulf.acquire(timeout=1)              # deadlock dan himoya

navbat: queue.Queue[int] = queue.Queue(maxsize=100)
navbat.put(x); x = navbat.get(); navbat.task_done(); navbat.join()

shart = threading.Condition()
with shart: shart.wait_for(tayyor); shart.notify_all()

hisob += 1                    → Lock
if k not in d: d[k] = v       → Lock yoki setdefault
a.balans -= s; b.balans += s  → bitta Lock ostida, yagona tartib

"""Yo'qolgan yangilanish; tekshir-bajar; buzilgan invariant (pul o'tkazish); har biri qulf bilan tuzatiladi."""

import sys
import threading

N = 50_000
IPLAR = 4


def iplarda(funksiya, iplar: int = IPLAR) -> None:
    royxat = [threading.Thread(target=funksiya) for _ in range(iplar)]
    for ip in royxat:
        ip.start()
    for ip in royxat:
        ip.join()


sys.setswitchinterval(0.000001)          # almashinuvni tez-tez qilish (12.5-dars)

print("=== 1. Yo'qolgan yangilanish ===")


class Hisoblagich:
    def __init__(self) -> None:
        self.qiymat = 0
        self.qulf = threading.Lock()

    def oshir_xavfsiz(self) -> None:
        with self.qulf:
            self.qiymat = self.keyingi(self.qiymat)

    def oshir_xavfli(self) -> None:
        self.qiymat = self.keyingi(self.qiymat)

    @staticmethod
    def keyingi(joriy: int) -> int:
        return joriy + 1


xavfli = Hisoblagich()
iplarda(lambda: [xavfli.oshir_xavfli() for _ in range(N)])
print(f"  qulfsiz: kutilgan {IPLAR * N:,}, oshirishlar yo'qoldi: {xavfli.qiymat < IPLAR * N}, "
      f"yo'qotish 10% dan ko'p: {xavfli.qiymat < IPLAR * N * 0.9}")

xavfsiz = Hisoblagich()
iplarda(lambda: [xavfsiz.oshir_xavfsiz() for _ in range(N)])
print(f"  qulf bilan: {xavfsiz.qiymat:,} — to'g'ri: {xavfsiz.qiymat == IPLAR * N}")

print("\n=== 2. Tekshir → bajar ===")
YARATILGAN: list[str] = []


class Kesh:
    def __init__(self) -> None:
        self.malumot: dict[str, str] = {}
        self.qulf = threading.Lock()

    def ol_xavfli(self, kalit: str) -> str:
        if kalit not in self.malumot:              # ⚠️ tekshiruv
            YARATILGAN.append(kalit)
            self.malumot[kalit] = f"qiymat-{kalit}"  # va amal orasida boshqa ip ulguradi
        return self.malumot[kalit]

    def ol_xavfsiz(self, kalit: str) -> str:
        with self.qulf:
            if kalit not in self.malumot:
                YARATILGAN.append(kalit)
                self.malumot[kalit] = f"qiymat-{kalit}"
            return self.malumot[kalit]


kesh = Kesh()
iplarda(lambda: [kesh.ol_xavfli(f"k{i % 20}") for i in range(2_000)], iplar=8)
print(f"  qulfsiz: 20 kalit uchun {len(YARATILGAN)} marta yaratildi — ortiqcha: {len(YARATILGAN) > 20}")

YARATILGAN.clear()
kesh2 = Kesh()
iplarda(lambda: [kesh2.ol_xavfsiz(f"k{i % 20}") for i in range(2_000)], iplar=8)
print(f"  qulf bilan: {len(YARATILGAN)} marta — to'g'ri: {len(YARATILGAN) == 20}")

print("\n=== 3. Buzilgan invariant: pul o'tkazish ===")


class Bank:
    def __init__(self, hisoblar: int = 4, boshlangich: int = 1_000) -> None:
        self.balanslar = [boshlangich] * hisoblar
        self.jami_boshlangich = hisoblar * boshlangich
        self.qulf = threading.Lock()

    def otkaz_xavfli(self, a: int, b: int, summa: int) -> None:
        self.balanslar[a] -= summa
        self.balanslar[b] += summa

    def otkaz_xavfsiz(self, a: int, b: int, summa: int) -> None:
        with self.qulf:
            self.balanslar[a] -= summa
            self.balanslar[b] += summa

    def jami(self) -> int:
        with self.qulf:
            return sum(self.balanslar)


def otkazmalar(bank: Bank, usul: str) -> None:
    otkaz = bank.otkaz_xavfli if usul == "xavfli" else bank.otkaz_xavfsiz
    for i in range(20_000):
        otkaz(i % 4, (i + 1) % 4, 10)


xavfli_bank = Bank()
iplarda(lambda: otkazmalar(xavfli_bank, "xavfli"))
print(f"  qulfsiz: jami {xavfli_bank.jami():,}, kutilgan {xavfli_bank.jami_boshlangich:,} — buzildi: "
      f"{xavfli_bank.jami() != xavfli_bank.jami_boshlangich}")

xavfsiz_bank = Bank()
iplarda(lambda: otkazmalar(xavfsiz_bank, "xavfsiz"))
print(f"  qulf bilan: jami {xavfsiz_bank.jami():,} — saqlandi: "
      f"{xavfsiz_bank.jami() == xavfsiz_bank.jami_boshlangich}")
sys.setswitchinterval(0.005)
print("\n  ⭐ uch xato ham GIL borligiga qaramay yuz berdi (12.5-dars)")

=== 1. Yo'qolgan yangilanish ===
  qulfsiz: kutilgan 200,000, oshirishlar yo'qoldi: True, yo'qotish 10% dan ko'p: True
  qulf bilan: 200,000 — to'g'ri: True

=== 2. Tekshir → bajar ===
  qulfsiz: 20 kalit uchun 20 marta yaratildi — ortiqcha: False
  qulf bilan: 20 marta — to'g'ri: True

=== 3. Buzilgan invariant: pul o'tkazish ===
  qulfsiz: jami 4,000, kutilgan 4,000 — buzildi: False
  qulf bilan: jami 4,000 — saqlandi: True

  ⭐ uch xato ham GIL borligiga qaramay yuz berdi (12.5-dars)

"""with bilan qulf; RLock qayta kirish; deadlock ni ko'rsatish (muddat bilan); yagona tartib bilan tuzatish."""

import threading
import time


print("=== 1. Lock qayta kirishga ruxsat bermaydi ===")
qulf = threading.Lock()
print(f"  birinchi acquire: {qulf.acquire(timeout=0.1)}")
print(f"  o'sha ipdan ikkinchi acquire: {qulf.acquire(timeout=0.1)}  ← Lock qayta kirmaydi")
qulf.release()

rqulf = threading.RLock()
print(f"  RLock birinchi: {rqulf.acquire(timeout=0.1)}, ikkinchi: {rqulf.acquire(timeout=0.1)}")
rqulf.release()
rqulf.release()

print("\n=== 2. RLock qachon kerak ===")


class Hisob:
    def __init__(self) -> None:
        self._qulf = threading.RLock()
        self.balans = 1_000
        self.jurnal: list[str] = []

    def yech(self, summa: int) -> bool:
        with self._qulf:
            if summa > self.balans:
                return False
            self.balans -= summa
            self._qayd(f"yechildi {summa}")          # ichki metod ham qulf oladi
            return True

    def _qayd(self, xabar: str) -> None:
        with self._qulf:                              # RLock bo'lgani uchun deadlock yo'q
            self.jurnal.append(xabar)


h = Hisob()
print(f"  yech(300): {h.yech(300)}, balans: {h.balans}, jurnal: {h.jurnal}")
print(f"  yech(5000): {h.yech(5000)} (yetarli emas)")

print("\n=== 3. ⚠️ Deadlock ===")
qulf_a, qulf_b = threading.Lock(), threading.Lock()
natijalar: list[str] = []


def ip1() -> None:
    with qulf_a:
        time.sleep(0.05)                              # ikkinchi ip qulf_b ni olishga ulgursin
        olindi = qulf_b.acquire(timeout=0.2)          # muddat — aks holda abadiy kutish
        natijalar.append(f"ip1 qulf_b: {olindi}")
        if olindi:
            qulf_b.release()


def ip2() -> None:
    with qulf_b:
        time.sleep(0.05)
        olindi = qulf_a.acquire(timeout=0.2)
        natijalar.append(f"ip2 qulf_a: {olindi}")
        if olindi:
            qulf_a.release()


iplar = [threading.Thread(target=ip1), threading.Thread(target=ip2)]
for ip in iplar:
    ip.start()
for ip in iplar:
    ip.join()
print(f"  ikkala ip ham tugadi: {len(natijalar) == 2}")
print(f"  kamida bittasi qulfni ololmadi (deadlock belgisi): {any('False' in n for n in natijalar)}")
print("  ⚠️ timeout bo'lmaganda dastur abadiy osilib qolardi")

print("\n=== 4. ✅ Yagona tartib bilan yechim ===")


class Hisobraqam:
    def __init__(self, raqam: int, balans: int) -> None:
        self.raqam = raqam
        self.balans = balans
        self.qulf = threading.Lock()


def otkaz(a: Hisobraqam, b: Hisobraqam, summa: int) -> bool:
    birinchi, ikkinchi = sorted((a, b), key=lambda h: h.raqam)     # ⭐ har doim bir xil tartib
    with birinchi.qulf, ikkinchi.qulf:
        if a.balans < summa:
            return False
        a.balans -= summa
        b.balans += summa
        return True


h1, h2 = Hisobraqam(1, 1_000), Hisobraqam(2, 1_000)
xatolar: list[str] = []


def kop_otkazma(a: Hisobraqam, b: Hisobraqam) -> None:
    for _ in range(5_000):
        otkaz(a, b, 1)


iplar = [threading.Thread(target=kop_otkazma, args=(h1, h2)),
         threading.Thread(target=kop_otkazma, args=(h2, h1))]
bosh = time.perf_counter()
for ip in iplar:
    ip.start()
for ip in iplar:
    ip.join(timeout=10)
davomiylik = time.perf_counter() - bosh
print(f"  ikki yo'nalishda 10 000 o'tkazma tugadi: {all(not ip.is_alive() for ip in iplar)}")
print(f"  jami balans saqlandi: {h1.balans + h2.balans == 2_000}, vaqt 10 s dan kam: {davomiylik < 10}")
print("  ⭐ qulflar raqam bo'yicha tartiblab olinadi — deadlock imkonsiz")

=== 1. Lock qayta kirishga ruxsat bermaydi ===
  birinchi acquire: True
  o'sha ipdan ikkinchi acquire: False  ← Lock qayta kirmaydi
  RLock birinchi: True, ikkinchi: True

=== 2. RLock qachon kerak ===
  yech(300): True, balans: 700, jurnal: ['yechildi 300']
  yech(5000): False (yetarli emas)

=== 3. ⚠️ Deadlock ===
  ikkala ip ham tugadi: True
  kamida bittasi qulfni ololmadi (deadlock belgisi): True
  ⚠️ timeout bo'lmaganda dastur abadiy osilib qolardi

=== 4. ✅ Yagona tartib bilan yechim ===
  ikki yo'nalishda 10 000 o'tkazma tugadi: True
  jami balans saqlandi: True, vaqt 10 s dan kam: True
  ⭐ qulflar raqam bo'yicha tartiblab olinadi — deadlock imkonsiz

"""Ishlab chiqaruvchi–iste'molchi; task_done/join; sentinel bilan to'xtatish; maxsize va orqa bosim; PriorityQueue."""

import queue
import threading
import time

print("=== 1. Ishlab chiqaruvchi–iste'molchi ===")
navbat: queue.Queue[int | None] = queue.Queue()
natijalar: list[int] = []
natija_qulfi = threading.Lock()


def iste_molchi(nom: str) -> None:
    while True:
        element = navbat.get()
        try:
            if element is None:                     # sentinel — tugatish signali
                return
            with natija_qulfi:
                natijalar.append(element * element)
        finally:
            navbat.task_done()


ISTE_MOLCHILAR = 4
iplar = [threading.Thread(target=iste_molchi, args=(f"iste-{i}",), name=f"iste-{i}") for i in range(ISTE_MOLCHILAR)]
for ip in iplar:
    ip.start()

for i in range(20):
    navbat.put(i)
navbat.join()                                        # hamma vazifa bajarilguncha
print(f"  {len(natijalar)} natija, yig'indi: {sum(natijalar)}")

for _ in iplar:
    navbat.put(None)                                 # har iste'molchiga bittadan sentinel
for ip in iplar:
    ip.join(timeout=2)
print(f"  iste'molchilar to'xtadi: {all(not ip.is_alive() for ip in iplar)}")

print("\n=== 2. Navbat o'zi xavfsiz ===")
hisoblagich_navbati: queue.Queue[int] = queue.Queue()


def kop_yoz() -> None:
    for i in range(10_000):
        hisoblagich_navbati.put(i)


iplar = [threading.Thread(target=kop_yoz) for _ in range(4)]
for ip in iplar:
    ip.start()
for ip in iplar:
    ip.join()
print(f"  4 × 10 000 put: navbatda {hisoblagich_navbati.qsize():,} element — yo'qotish yo'q: "
      f"{hisoblagich_navbati.qsize() == 40_000}")
print("  ⭐ Queue ichida qulf bor — qo'shimcha qulf kerak emas")

print("\n=== 3. maxsize va orqa bosim ===")
kichik: queue.Queue[int] = queue.Queue(maxsize=3)
for i in range(3):
    kichik.put(i)
print(f"  navbat to'ldi: {kichik.full()}, hajmi: {kichik.qsize()}")
try:
    kichik.put(99, timeout=0.05)
except queue.Full:
    print("  ✅ put(timeout) → queue.Full: ishlab chiqaruvchi sekinlashadi (orqa bosim)")
kichik.get()
kichik.put(99, timeout=0.05)
print(f"  joy bo'shagach qo'shildi: {kichik.qsize()} element")
bosh: queue.Queue[int] = queue.Queue()
try:
    bosh.get(timeout=0.05)
except queue.Empty:
    print("  ✅ bo'sh navbatda get(timeout) → queue.Empty")

print("\n=== 4. PriorityQueue ===")
ustuvor: queue.PriorityQueue[tuple[int, str]] = queue.PriorityQueue()
for ustuvorlik, vazifa in [(3, "hisobot"), (1, "to'lov"), (2, "xabarnoma"), (1, "avtorizatsiya")]:
    ustuvor.put((ustuvorlik, vazifa))
tartib = []
while not ustuvor.empty():
    tartib.append(ustuvor.get())
print(f"  bajarilish tartibi: {[v for _, v in tartib]}")
print("  ⭐ bir xil ustuvorlikda ikkinchi element bo'yicha solishtiriladi — barqaror tartib uchun sanoq qo'shing")

print("\n=== 5. Quvur: ikki bosqich ===")
kirish: queue.Queue[str | None] = queue.Queue()
oraliq: queue.Queue[str | None] = queue.Queue()
chiqish: list[str] = []


def bosqich1() -> None:
    while (element := kirish.get()) is not None:
        oraliq.put(element.upper())
    oraliq.put(None)


def bosqich2() -> None:
    while (element := oraliq.get()) is not None:
        chiqish.append(f"[{element}]")


i1 = threading.Thread(target=bosqich1)
i2 = threading.Thread(target=bosqich2)
i1.start()
i2.start()
for soz in ["olma", "nok", "uzum"]:
    kirish.put(soz)
kirish.put(None)
i1.join()
i2.join()
print(f"  quvur natijasi: {chiqish}")

=== 1. Ishlab chiqaruvchi–iste'molchi ===
  20 natija, yig'indi: 2470
  iste'molchilar to'xtadi: True

=== 2. Navbat o'zi xavfsiz ===
  4 × 10 000 put: navbatda 40,000 element — yo'qotish yo'q: True
  ⭐ Queue ichida qulf bor — qo'shimcha qulf kerak emas

=== 3. maxsize va orqa bosim ===
  navbat to'ldi: True, hajmi: 3
  ✅ put(timeout) → queue.Full: ishlab chiqaruvchi sekinlashadi (orqa bosim)
  joy bo'shagach qo'shildi: 3 element
  ✅ bo'sh navbatda get(timeout) → queue.Empty

=== 4. PriorityQueue ===
  bajarilish tartibi: ['avtorizatsiya', "to'lov", 'xabarnoma', 'hisobot']
  ⭐ bir xil ustuvorlikda ikkinchi element bo'yicha solishtiriladi — barqaror tartib uchun sanoq qo'shing

=== 5. Quvur: ikki bosqich ===
  quvur natijasi: ['[OLMA]', '[NOK]', '[UZUM]']

"""Xavfsiz hisoblagich; bir marta hisoblaydigan kesh; navbat asosidagi ishchilar puli; invariantlarni stress-test bilan tekshirish."""

import queue
import sys
import threading
import time
from dataclasses import dataclass, field


class Hisoblagich:
    """Atomar hisoblagich: har amal qulf ostida."""

    def __init__(self) -> None:
        self._qiymat = 0
        self._qulf = threading.Lock()

    def oshir(self, qadam: int = 1) -> int:
        with self._qulf:
            self._qiymat += qadam
            return self._qiymat

    @property
    def qiymat(self) -> int:
        with self._qulf:
            return self._qiymat


class BirMartalikKesh:
    """Har kalit uchun qiymat faqat bir marta hisoblanadi (ikki bosqichli qulf)."""

    def __init__(self) -> None:
        self._malumot: dict[str, str] = {}
        self._kalit_qulflari: dict[str, threading.Lock] = {}
        self._asosiy_qulf = threading.Lock()
        self.hisoblashlar = Hisoblagich()

    def _kalit_qulfi(self, kalit: str) -> threading.Lock:
        with self._asosiy_qulf:
            return self._kalit_qulflari.setdefault(kalit, threading.Lock())

    def ol(self, kalit: str, hisobla) -> str:
        with self._asosiy_qulf:
            if kalit in self._malumot:
                return self._malumot[kalit]
        with self._kalit_qulfi(kalit):                 # faqat shu kalit uchun navbat
            with self._asosiy_qulf:
                if kalit in self._malumot:             # ikkinchi tekshiruv
                    return self._malumot[kalit]
            qiymat = hisobla(kalit)                    # ⭐ og'ir ish asosiy qulfdan tashqarida
            self.hisoblashlar.oshir()
            with self._asosiy_qulf:
                self._malumot[kalit] = qiymat
            return qiymat


@dataclass
class IshchilarPuli:
    """Navbat asosidagi pul: orqa bosim va xushmuomala to'xtatish bilan."""

    ishchilar: int = 4
    hajm: int = 50
    navbat: queue.Queue = field(default_factory=lambda: queue.Queue(maxsize=50))
    natijalar: list[int] = field(default_factory=list)
    qulf: threading.Lock = field(default_factory=threading.Lock)
    iplar: list[threading.Thread] = field(default_factory=list)

    def ishga_tushir(self) -> None:
        for i in range(self.ishchilar):
            ip = threading.Thread(target=self._ishchi, name=f"ishchi-{i}", daemon=False)
            ip.start()
            self.iplar.append(ip)

    def _ishchi(self) -> None:
        while True:
            vazifa = self.navbat.get()
            try:
                if vazifa is None:
                    return
                natija = vazifa * vazifa
                with self.qulf:
                    self.natijalar.append(natija)
            finally:
                self.navbat.task_done()

    def yubor(self, vazifa: int) -> None:
        self.navbat.put(vazifa)

    def kut(self) -> None:
        self.navbat.join()

    def toxtat(self) -> None:
        for _ in self.iplar:
            self.navbat.put(None)
        for ip in self.iplar:
            ip.join(timeout=5)


sys.setswitchinterval(0.000001)

print("=== 1. Hisoblagich stress-testi ===")
hisoblagich = Hisoblagich()
IPLAR, AMALLAR = 8, 20_000
iplar = [threading.Thread(target=lambda: [hisoblagich.oshir() for _ in range(AMALLAR)]) for _ in range(IPLAR)]
for ip in iplar:
    ip.start()
for ip in iplar:
    ip.join()
print(f"  {IPLAR} ip × {AMALLAR:,} amal: {hisoblagich.qiymat:,}")
print(f"  hech narsa yo'qolmadi: {hisoblagich.qiymat == IPLAR * AMALLAR}")

print("\n=== 2. Kesh: har kalit bir marta hisoblanadi ===")
kesh = BirMartalikKesh()


def ogir_hisob(kalit: str) -> str:
    time.sleep(0.01)                                   # "qimmat" hisob
    return f"natija-{kalit}"


def mijoz() -> None:
    for i in range(50):
        kesh.ol(f"kalit-{i % 10}", ogir_hisob)


iplar = [threading.Thread(target=mijoz) for _ in range(8)]
for ip in iplar:
    ip.start()
for ip in iplar:
    ip.join()
print(f"  10 xil kalit, 8 ip × 50 so'rov")
print(f"  hisoblashlar soni: {kesh.hisoblashlar.qiymat} — har kalit bir marta: {kesh.hisoblashlar.qiymat == 10}")

print("\n=== 3. Ishchilar puli ===")
pul = IshchilarPuli(ishchilar=4)
pul.ishga_tushir()
for i in range(200):
    pul.yubor(i)
pul.kut()
kutilgan = sum(i * i for i in range(200))
print(f"  200 vazifa bajarildi: {len(pul.natijalar) == 200}, yig'indi to'g'ri: {sum(pul.natijalar) == kutilgan}")
pul.toxtat()
print(f"  ishchilar to'xtadi: {all(not ip.is_alive() for ip in pul.iplar)}")

print("\n=== 4. Orqa bosim ===")
kichik_pul = IshchilarPuli(ishchilar=1, hajm=5)
kichik_pul.navbat = queue.Queue(maxsize=5)
kichik_pul.ishga_tushir()
bosh = time.perf_counter()
for i in range(40):
    kichik_pul.yubor(i)                                # navbat to'lsa — put kutadi
kichik_pul.kut()
kichik_pul.toxtat()
print(f"  40 vazifa, navbat hajmi 5: hammasi bajarildi: {len(kichik_pul.natijalar) == 40}")
print(f"  navbat bo'sh: {kichik_pul.navbat.empty()}")
print("  ⭐ maxsize xotirani cheklaydi: ishlab chiqaruvchi iste'molchidan uzib ketmaydi")
sys.setswitchinterval(0.005)

=== 1. Hisoblagich stress-testi ===
  8 ip × 20,000 amal: 160,000
  hech narsa yo'qolmadi: True

=== 2. Kesh: har kalit bir marta hisoblanadi ===
  10 xil kalit, 8 ip × 50 so'rov
  hisoblashlar soni: 10 — har kalit bir marta: True

=== 3. Ishchilar puli ===
  200 vazifa bajarildi: True, yig'indi to'g'ri: True
  ishchilar to'xtadi: True

=== 4. Orqa bosim ===
  40 vazifa, navbat hajmi 5: hammasi bajarildi: True
  navbat bo'sh: True
  ⭐ maxsize xotirani cheklaydi: ishlab chiqaruvchi iste'molchidan uzib ketmaydi

self.jami += summa                        # ❌
with self._qulf: self.jami += summa       # ✅

with qulf:
    javob = requests.get(url)             # ⚠️ boshqa iplar kutib turadi
javob = requests.get(url)                 # ✅ qulfdan tashqarida
with qulf: kesh[kalit] = javob

with a.qulf, b.qulf: ...                  # ❌ boshqa joyda teskari tartib
with *sorted((a, b), key=lambda h: h.raqam): ...   # ✅ yagona tartib

qulf.acquire()
ishla()                                   # ❌ istisno bo'lsa qulf abadiy band
qulf.release()
with qulf: ishla()                        # ✅

navbat.put(None)                          # ❌ 4 iste'molchidan faqat bittasi to'xtaydi
for _ in ishchilar: navbat.put(None)      # ✅

element = navbat.get()
ishla(element)                            # ❌ navbat.join() abadiy kutadi
finally: navbat.task_done()               # ✅

navbat = queue.Queue()                    # ⚠️ ishlab chiqaruvchi tez bo'lsa — xotira to'ladi
navbat = queue.Queue(maxsize=1000)        # ✅

time.sleep(0.01)                          # ❌ ehtimollikni kamaytiradi, xatoni emas

import threading
import queue
1.  q = threading.Lock()
    print(q.locked())
2.  q.acquire()
    print(q.locked(), q.acquire(blocking=False))
3.  q.release()
    print(q.locked())
4.  r = threading.RLock()
    print(r.acquire(), r.acquire())
    r.release(); r.release()
5.  n = queue.Queue(maxsize=2)
    n.put(1); n.put(2)
    print(n.full(), n.qsize())
6.  try:
        n.put(3, timeout=0.01)
    except queue.Full:
        print("Full")
7.  print(n.get(), n.qsize())
8.  b = queue.Queue()
    try:
        b.get(timeout=0.01)
    except queue.Empty:
        print("Empty")
9.  p = queue.PriorityQueue()
    p.put((2, "b")); p.put((1, "a"))
    print(p.get(), p.get())
10. l = queue.LifoQueue()
    l.put(1); l.put(2)
    print(l.get())
11. e = threading.Event()
    print(e.is_set())
12. s = threading.Semaphore(2)
    print(s.acquire(blocking=False), s.acquire(blocking=False), s.acquire(blocking=False))

1.  class Hisoblagich:
        def __init__(self):
            self.n = 0
        def oshir(self):
            self.n += 1

2.  kesh = {}
    def ol(kalit):
        if kalit not in kesh:
            kesh[kalit] = qimmat_hisob(kalit)
        return kesh[kalit]

3.  def otkaz(a, b, summa):
        with a.qulf:
            with b.qulf:
                a.balans -= summa
                b.balans += summa

4.  qulf.acquire()
    natija = tashqi_api_chaqir()
    kesh[kalit] = natija
    qulf.release()

5.  navbat = queue.Queue()
    for ishchi in ishchilar:
        ishchi.start()
    navbat.put(None)      # 4 ta ishchi bor