12.5-dars: GIL nima va nega bor

Yadro 1:  ip A ████████░░░░░░░░████████░░░░░░░░
Yadro 2:  ip B ░░░░░░░░████████░░░░░░░░████████
               ← GIL navbat bilan uzatiladi →

obj->ob_refcnt++;      /* aslida: o'qi → qo'sh → yoz (3 mashina amali) */

ip A GIL ushlab ishlayapti
ip B GIL kutmoqda ──── 5 ms (switch interval) o'tdi ────► "bo'shat" so'rovi
ip A keyingi tekshiruv nuqtasida GIL ni bo'shatadi
ip B GIL ni oladi

hisob.ball = yangi_ball(hisob.ball)
# ip A: o'qidi 100       ip B: o'qidi 100
# ip A: yozdi 101        ip B: yozdi 101     ← bitta oshirish yo'qoldi

sys.getswitchinterval()     → 0.005       sys.setswitchinterval(s)
sys._is_gil_enabled()       → True/False
sysconfig.get_config_var("Py_GIL_DISABLED")   → 1 erkin ipli yig'mada
PYTHON_GIL=0 / -X gil=0     (faqat erkin ipli yig'mada)

bir interpretator — bir vaqtda bitta ip Python kodini bajaradi
I/O, sleep, lock kutish, hashlib/zlib/NumPy → GIL bo'shatiladi
sof Python CPU ish → iplarda parallel emas
GIL ≠ sizning kodingiz uchun xavfsizlik → Lock

CPU: ProcessPoolExecutor, InterpreterPoolExecutor (3.14), C kengaytma, python3.14t
I/O: ThreadPoolExecutor, asyncio

"""Yig'ma ma'lumoti; sof Python CPU ish 1 va 4 ipda; sleep 4 ipda; eval breaker: almashish qayerda sodir bo'ladi."""

import sys
import sysconfig
import threading
import time


def iplarda(funksiya, iplar, *args):
    royxat = [threading.Thread(target=funksiya, args=args) for _ in range(iplar)]
    bosh = time.perf_counter()
    for ip in royxat:
        ip.start()
    for ip in royxat:
        ip.join()
    return time.perf_counter() - bosh


def eng_yaxshi(funksiya, iplar, *args, takror=3):
    return min(iplarda(funksiya, iplar, *args) for _ in range(takror))


print("=== 1. Yig'ma ===")
print(f"  versiya: {sys.version_info[:2]}, erkin ipli yig'ma: {bool(sysconfig.get_config_var('Py_GIL_DISABLED'))}")
print(f"  GIL yoqilgan: {sys._is_gil_enabled()}, switch interval: {sys.getswitchinterval()} s")


def hisobla(n=2_000_000):
    s = 0
    for i in range(n):
        s += i * i
    return s


print("\n=== 2. Sof Python hisoblash ===")
bitta = eng_yaxshi(hisobla, 1)
tort = eng_yaxshi(hisobla, 4)
print("  4 ip 4 barobar ish qildi; parallel bo'lganda vaqt 1 ipnikiga teng bo'lardi")
print(f"  haqiqatda kamida 3 barobar uzoqroq (ketma-ket kabi yoki yomonroq): {tort / bitta >= 3}")


def kut():
    time.sleep(0.2)


print("\n=== 3. Kutish (I/O ga o'xshash) ===")
vaqt = eng_yaxshi(kut, 8)
print(f"  8 ip, har biri 0.2 s uxlaydi: jami {vaqt:.2f} s — parallel: {vaqt < 0.4}")

print("\n=== 4. Almashish nuqtalari ===")
navbat = []


def ishchi(nom, bosqichlar):
    for _ in range(bosqichlar):
        hisobla(300_000)
        navbat.append(nom)


iplarda_ = [threading.Thread(target=ishchi, args=(nom, 6)) for nom in "AB"]
for ip in iplarda_:
    ip.start()
for ip in iplarda_:
    ip.join()
almashishlar = sum(1 for a, b in zip(navbat, navbat[1:]) if a != b)
print(f"  12 bosqich, ikki ip: ular aralashib ishladi (kamida bitta almashish): {almashishlar >= 1}")
print("  lekin bir vaqtda emas — GIL navbat bilan uzatildi (2-bo'lim)")

=== 1. Yig'ma ===
  versiya: (3, 14), erkin ipli yig'ma: False
  GIL yoqilgan: True, switch interval: 0.005 s

=== 2. Sof Python hisoblash ===
  4 ip 4 barobar ish qildi; parallel bo'lganda vaqt 1 ipnikiga teng bo'lardi
  haqiqatda kamida 3 barobar uzoqroq (ketma-ket kabi yoki yomonroq): True

=== 3. Kutish (I/O ga o'xshash) ===
  8 ip, har biri 0.2 s uxlaydi: jami 0.20 s — parallel: True

=== 4. Almashish nuqtalari ===
  12 bosqich, ikki ip: ular aralashib ishladi (kamida bitta almashish): True
  lekin bir vaqtda emas — GIL navbat bilan uzatildi (2-bo'lim)

"""O'qi-hisobla-yoz: switch interval bilan yo'qotishlar; list.append atomar; tekshir-bajar poygasi; Lock bilan tuzatish."""

import sys
import threading
import time


def iplarda(funksiya, iplar=4):
    royxat = [threading.Thread(target=funksiya) for _ in range(iplar)]
    for ip in royxat:
        ip.start()
    for ip in royxat:
        ip.join()


class Hisob:
    def __init__(self):
        self.ball = 0


def yangi_ball(eski):
    return eski + 1


N = 100_000

print("=== 1. hisob.ball = yangi_ball(hisob.ball) ===")
sys.setswitchinterval(0.000001)
hisob = Hisob()


def oshir():
    for _ in range(N):
        hisob.ball = yangi_ball(hisob.ball)


iplarda(oshir)
print(f"  kutilgan {4 * N:,}, oshirishlar yo'qoldi: {hisob.ball < 4 * N}, yo'qotish 1% dan ko'p: {hisob.ball < 0.99 * 4 * N}")
print("  (switch interval 1 mks — sukut 5 ms da xuddi shu xato kamdan-kam, lekin baribir bo'ladi)")

qulf = threading.Lock()
hisob = Hisob()


def qulf_bilan():
    for _ in range(N):
        with qulf:
            hisob.ball = yangi_ball(hisob.ball)


iplarda(qulf_bilan)
print(f"  Lock bilan: {hisob.ball:,} — to'g'ri: {hisob.ball == 4 * N}")

print("\n=== 2. Bitta ichki amal: list.append ===")
royxat = []


def qosh():
    for i in range(N):
        royxat.append(i)


iplarda(qosh)
print(f"  4 × {N:,} append: {len(royxat):,} — yo'qotish yo'q: {len(royxat) == 4 * N}")

print("\n=== 3. Tekshir → bajar ===")
yaratilgan = []


class Ulanish:
    def __init__(self, nom):
        time.sleep(0.001)                      # tarmoq ulanishi simulyatsiyasi
        yaratilgan.append(nom)


kesh = {}


def ulanish_ol(nom):
    if nom not in kesh:
        ulanish = Ulanish(nom)
        kesh[nom] = ulanish
    return kesh[nom]


def mijoz():
    for i in range(2_000):
        ulanish_ol(f"db-{i % 50}")


iplarda(mijoz, iplar=8)
print(f"  50 xil nom uchun ortiqcha ulanishlar yaratildi: {len(yaratilgan) > 50}")

yaratilgan.clear()
kesh.clear()
kesh_qulfi = threading.Lock()


def ulanish_ol_xavfsiz(nom):
    with kesh_qulfi:
        if nom not in kesh:
            kesh[nom] = Ulanish(nom)
        return kesh[nom]


def mijoz_xavfsiz():
    for i in range(2_000):
        ulanish_ol_xavfsiz(f"db-{i % 50}")


iplarda(mijoz_xavfsiz, iplar=8)
print(f"  qulf bilan: {len(yaratilgan)} ta ulanish — to'g'ri: {len(yaratilgan) == 50}")
sys.setswitchinterval(0.005)

=== 1. hisob.ball = yangi_ball(hisob.ball) ===
  kutilgan 400,000, oshirishlar yo'qoldi: True, yo'qotish 1% dan ko'p: True
  (switch interval 1 mks — sukut 5 ms da xuddi shu xato kamdan-kam, lekin baribir bo'ladi)
  Lock bilan: 400,000 — to'g'ri: True

=== 2. Bitta ichki amal: list.append ===
  4 × 100,000 append: 400,000 — yo'qotish yo'q: True

=== 3. Tekshir → bajar ===
  50 xil nom uchun ortiqcha ulanishlar yaratildi: True
  qulf bilan: 50 ta ulanish — to'g'ri: True

"""hashlib katta va kichik ma'lumotda; zlib; sof Python va C kutubxonasi solishtiruvi; iplar tezlanishi nisbati."""

import hashlib
import os
import threading
import time
import zlib

KATTA = os.urandom(40_000_000)
KICHIK = [os.urandom(64) for _ in range(200_000)]


def iplarda(funksiya, iplar):
    royxat = [threading.Thread(target=funksiya) for _ in range(iplar)]
    bosh = time.perf_counter()
    for ip in royxat:
        ip.start()
    for ip in royxat:
        ip.join()
    return time.perf_counter() - bosh


def tezlanish(funksiya, iplar=4, takror=5):
    bitta = min(iplarda(funksiya, 1) for _ in range(takror))
    kop = min(iplarda(funksiya, iplar) for _ in range(takror))
    return iplar * bitta / kop


def katta_xesh():
    hashlib.sha256(KATTA).digest()


def kichik_xeshlar():
    for bolak in KICHIK:
        hashlib.sha256(bolak).digest()


def siqish():
    zlib.compress(KATTA[:8_000_000], 6)


def sof_python_xesh():
    h = 0
    for b in KATTA[:3_000_000]:
        h = (h * 31 + b) & 0xFFFFFFFF


print("=== 4 ip, 4 barobar ish: bir xil sharoitda o'lchangan tezlanish ===")
t_katta = tezlanish(katta_xesh)
t_kichik = tezlanish(kichik_xeshlar)
t_sof = tezlanish(sof_python_xesh)
print(f"  eng yaxshi tezlangan ish: {max([('sha256(40 MB)', t_katta), ('sha256 × 200 000 kichik', t_kichik), ('sof Python sikl', t_sof)], key=lambda j: j[1])[0]}")
print(f"  sha256(40 MB) kichik bo'laklardan kamida 2 barobar yaxshi tezlandi: {t_katta > 2 * t_kichik}")
print(f"  sha256(40 MB) sof Python sikldan kamida 2 barobar yaxshi tezlandi: {t_katta > 2 * t_sof}")
print(f"  kichik bo'laklar sof Python sikliga yaqin (GIL ushlanadi): {t_kichik < 2 * t_sof}")
print("\n  hashlib GIL ni faqat katta ma'lumotda bo'shatadi; kichik bo'laklarda chaqiruvlar orasidagi Python kodi GIL talab qiladi")

=== 4 ip, 4 barobar ish: bir xil sharoitda o'lchangan tezlanish ===
  eng yaxshi tezlangan ish: sha256(40 MB)
  sha256(40 MB) kichik bo'laklardan kamida 2 barobar yaxshi tezlandi: True
  sha256(40 MB) sof Python sikldan kamida 2 barobar yaxshi tezlandi: True
  kichik bo'laklar sof Python sikliga yaqin (GIL ushlanadi): True

  hashlib GIL ni faqat katta ma'lumotda bo'shatadi; kichik bo'laklarda chaqiruvlar orasidagi Python kodi GIL talab qiladi

"""Funksiyani 1 va N ipda o'lchash; samarali tezlanish; tasnif va tavsiya; I/O, C kutubxona, sof Python, json va re."""

import hashlib
import json
import os
import re
import sys
import threading
import time
from dataclasses import dataclass


@dataclass
class Tashxis:
    nom: str
    tezlanish: float
    asos: float          # ataylab GIL ushlaydigan ish uchun o'lchangan tezlanish

    @property
    def tasnif(self):
        """Mutlaq chegara emas, xuddi shu mashinada o'lchangan asosga nisbatan."""
        if self.tezlanish >= 2.5 * self.asos:
            return "parallel"
        if self.tezlanish <= 2.0 * self.asos:
            return "GIL bilan cheklangan"
        return "qisman"

    @property
    def tavsiya(self):
        return {
            "parallel": "ThreadPoolExecutor yetarli",
            "GIL bilan cheklangan": "ProcessPoolExecutor / InterpreterPoolExecutor yoki C kengaytma",
            "qisman": "o'lchab tanlang: iplar va jarayonlar",
        }[self.tasnif]


def iplar_foydasi(nom, funksiya, asos=1.0, iplar=4, takror=5):
    def olch(k):
        eng = float("inf")
        for _ in range(takror):
            royxat = [threading.Thread(target=funksiya) for _ in range(k)]
            bosh = time.perf_counter()
            for ip in royxat:
                ip.start()
            for ip in royxat:
                ip.join()
            eng = min(eng, time.perf_counter() - bosh)
        return eng
    return Tashxis(nom, iplar * olch(1) / olch(iplar), asos)


MALUMOT = [{"id": i, "ism": f"talaba{i}", "baholar": list(range(i % 10))} for i in range(20_000)]
MATN = " ".join(f"user{i}@wisar.uz tel:+99890{i:07d}" for i in range(20_000))
RASM = os.urandom(30_000_000)


def tarmoq_sorovi():
    time.sleep(0.15)


def rasm_xeshi():
    hashlib.blake2b(RASM).digest()


def eskiz_sof_python():
    piksellar = RASM[:600_000]
    return bytes((piksellar[i] + piksellar[i + 1]) // 2 for i in range(0, len(piksellar) - 1, 2))


def json_serializatsiya():
    json.dumps(MALUMOT)


def regex_qidiruv():
    re.findall(r"[\w.]+@[\w.]+", MATN)


print(f"=== Diagnostika (GIL: {sys._is_gil_enabled()}) ===")
ishlar = [("tarmoq so'rovi (sleep)", tarmoq_sorovi), ("blake2b(30 MB)", rasm_xeshi),
          ("eskiz, sof Python", eskiz_sof_python), ("json.dumps", json_serializatsiya), ("re.findall", regex_qidiruv)]
asos = iplar_foydasi("asos", eskiz_sof_python).tezlanish     # sof Python — ataylab GIL bilan cheklangan
print(f"  asos (sof Python ish) tezlanishi 1 ga yaqin: {asos < 2}\n")
for nom, funksiya in ishlar:
    t = iplar_foydasi(nom, funksiya, asos=asos)
    print(f"  {t.nom:24} → {t.tasnif:22} {t.tavsiya}")

=== Diagnostika (GIL: True) ===
  asos (sof Python ish) tezlanishi 1 ga yaqin: True

  tarmoq so'rovi (sleep)   → parallel               ThreadPoolExecutor yetarli
  blake2b(30 MB)           → parallel               ThreadPoolExecutor yetarli
  eskiz, sof Python        → GIL bilan cheklangan   ProcessPoolExecutor / InterpreterPoolExecutor yoki C kengaytma
  json.dumps               → GIL bilan cheklangan   ProcessPoolExecutor / InterpreterPoolExecutor yoki C kengaytma
  re.findall               → GIL bilan cheklangan   ProcessPoolExecutor / InterpreterPoolExecutor yoki C kengaytma

with ThreadPoolExecutor(16) as ex:
    list(ex.map(eskiz_yasa, rasmlar))       # ❌ sof Python — tezlashmaydi
with ProcessPoolExecutor() as ex:
    list(ex.map(eskiz_yasa, rasmlar))       # ✅ (12.6-dars)

self.ball = self.hisobla(self.ball)          # ❌ ko'p ipda
with self._qulf:
    self.ball = self.hisobla(self.ball)      # ✅

if kalit not in kesh:
    kesh[kalit] = qimmat_yasash()            # ❌ bir necha ip bir vaqtda yasaydi

sys.setswitchinterval(1)                     # ❌ ehtimollikni kamaytiradi, xatoni emas

# test: 2 ip, 1000 iteratsiya — hammasi to'g'ri   ❌ production: 32 ip, soatlab yuk

for bolak in bolaklar_64_bayt:
    hashlib.sha256(bolak)                    # ⚠️ GIL deyarli bo'shatilmaydi
hashlib.sha256(b"".join(bolaklar))           # ✅ bitta katta chaqiruv (agar mantiqqa to'g'ri kelsa)

python3.14t app.py                           # ⚠️ bitta eski kengaytma GIL ni qayta yoqadi
python3.14t -c "import sys, app; print(sys._is_gil_enabled())"   # ✅ tekshiruv

# ❌ chiqish tartibi har ishga tushishda boshqacha — test assertlari tartibga bog'lanmasin

import sys
import threading
1.  print(sys.getswitchinterval())
2.  print(sys._is_gil_enabled())
3.  print(threading.active_count())
4.  print(threading.current_thread().name)
5.  natija = []
    ip = threading.Thread(target=lambda: natija.append(threading.current_thread().name), name="ishchi-1")
    ip.start()
    ip.join()
    print(natija)
6.  royxat = []
    iplar = [threading.Thread(target=lambda: royxat.extend(range(1000))) for _ in range(4)]
    for t in iplar:
        t.start()
    for t in iplar:
        t.join()
    print(len(royxat))
7.  sys.setswitchinterval(0.01)
    print(sys.getswitchinterval())
8.  sys.setswitchinterval(0.005)
    q = threading.Lock()
    print(q.acquire(blocking=False), q.acquire(blocking=False))
9.  q.release()
    print(q.locked())
10. r = threading.RLock()
    with r:
        with r:
            print("RLock qayta kirildi")
11. ip = threading.Thread(target=lambda: None, daemon=True)
    print(ip.daemon, ip.is_alive())
12. import sysconfig
    print(sysconfig.get_config_var("Py_GIL_DISABLED"))

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

2.  with ThreadPoolExecutor(max_workers=os.cpu_count()) as ex:
        natijalar = list(ex.map(tub_sonlar_soni, oraliqlar))

3.  _nusxa = None
    def sozlama():
        global _nusxa
        if _nusxa is None:
            _nusxa = Sozlama.fayldan_yukla()
        return _nusxa

4.  def xeshla(fayllar):
        with ThreadPoolExecutor(8) as ex:
            return list(ex.map(lambda yol: hashlib.sha256(open(yol, "rb").read()).hexdigest(), fayllar))

5.  def test_hisoblagich():
        h = Hisoblagich()
        iplar = [threading.Thread(target=h.oshir) for _ in range(2)]
        ...
        assert h.qiymat == 2      # "o'tdi — demak xavfsiz"