14.4-dars: multiprocessing

jarayon = mp.Process(target=funksiya, args=(1,), name="ishchi", daemon=False)
jarayon.start()
jarayon.join(timeout=30)
jarayon.exitcode        # 0 — muvaffaqiyat, >0 — xato, <0 — signal

mp.set_start_method("spawn", force=True)    # dastur boshida bir marta

def main() -> None:
    ...

if __name__ == "__main__":      # ✅ shartsiz — cheksiz jarayon ko'payishi
    main()

v = mp.Value("i", 0); qulf = mp.Lock()
with qulf:
    v.value += 1                      # umumiy xotira, qulf bilan

shm = shared_memory.SharedMemory(create=True, size=1_000_000)
shm.buf[0] = 42                       # nusxasiz
shm.close(); shm.unlink()             # egasi unlink qiladi

import multiprocessing as mp

def ishchi(x, natijalar): natijalar.put(x * x)      # modul darajasida!

if __name__ == "__main__":                          # majburiy
    mp.set_start_method("spawn", force=True)
    natijalar = mp.Queue()
    p = mp.Process(target=ishchi, args=(5, natijalar))
    p.start()
    qiymat = natijalar.get(timeout=10)              # avval get
    p.join(timeout=10)                              # keyin join
    print(qiymat, p.exitcode)

Queue/Pipe → pickle    Value/Array → umumiy xotira + Lock
shared_memory → katta massivlar, nusxasiz
Manager → qulay, sekin

"""Jarayon yaratish; alohida PID va xotira; exitcode; terminate; daemon; __main__ qoidasi."""

import multiprocessing as mp
import os
import sys
import time

HISOB = 0          # har jarayonda o'z nusxasi bo'ladi


def kim_men(navbat: mp.Queue) -> None:
    global HISOB
    HISOB += 100
    navbat.put((os.getpid(), HISOB))


def uzoq_ishchi() -> None:
    time.sleep(30)


def chiqish_kodi_bilan(kod: int) -> None:
    sys.exit(kod)


def main() -> None:
    print("=== 1. Alohida jarayonlar ===")
    navbat: mp.Queue = mp.Queue()
    jarayonlar = [mp.Process(target=kim_men, args=(navbat,), name=f"ishchi-{i}") for i in range(3)]
    for j in jarayonlar:
        j.start()
    natijalar = [navbat.get(timeout=15) for _ in jarayonlar]
    for j in jarayonlar:
        j.join(timeout=15)
    pidlar = {pid for pid, _ in natijalar}
    print(f"  {len(pidlar)} xil PID, asosiy jarayon ular orasida emas: {os.getpid() not in pidlar}")
    print(f"  har jarayonda HISOB mustaqil o'zgardi: {sorted(h for _, h in natijalar)}")
    print(f"  asosiy jarayonda HISOB o'zgarmadi: {HISOB}")
    print(f"  exitcode lar: {[j.exitcode for j in jarayonlar]}")

    print("\n=== 2. exitcode ===")
    normal = mp.Process(target=chiqish_kodi_bilan, args=(0,))
    normal.start()
    normal.join(timeout=15)
    xatoli = mp.Process(target=chiqish_kodi_bilan, args=(3,))
    xatoli.start()
    xatoli.join(timeout=15)
    print(f"  sys.exit(0) → exitcode {normal.exitcode}")
    print(f"  sys.exit(3) → exitcode {xatoli.exitcode}")
    print("  (ushlanmagan istisno → exitcode 1, traceback bolaning stderr iga chiqadi)")

    print("\n=== 3. terminate ===")
    uzoq = mp.Process(target=uzoq_ishchi, daemon=True, name="uzoq")
    uzoq.start()
    time.sleep(0.2)
    print(f"  ishlayaptimi: {uzoq.is_alive()}")
    uzoq.terminate()
    uzoq.join(timeout=10)
    print(f"  terminate dan keyin: tirik={uzoq.is_alive()}, exitcode={uzoq.exitcode} (manfiy — signal)")
    print("  ⚠️ terminate tozalashni (finally, with) bajarmaydi")

    print("\n=== 4. Ishga tushirish usuli ===")
    print(f"  joriy usul: {mp.get_start_method()}")
    print(f"  mavjud usullar: {sorted(mp.get_all_start_methods())}")
    print(f"  yadrolar: {mp.cpu_count() >= 1}")
    print("  ⭐ spawn/forkserver da bola modulni qayta import qiladi —")
    print("     shuning uchun butun ishga tushirish kodi if __name__ == '__main__' ichida")


if __name__ == "__main__":
    main()

=== 1. Alohida jarayonlar ===
  3 xil PID, asosiy jarayon ular orasida emas: True
  har jarayonda HISOB mustaqil o'zgardi: [100, 100, 100]
  asosiy jarayonda HISOB o'zgarmadi: 0
  exitcode lar: [0, 0, 0]

=== 2. exitcode ===
  sys.exit(0) → exitcode 0
  sys.exit(3) → exitcode 3
  (ushlanmagan istisno → exitcode 1, traceback bolaning stderr iga chiqadi)

=== 3. terminate ===
  ishlayaptimi: True
  terminate dan keyin: tirik=False, exitcode=-15 (manfiy — signal)
  ⚠️ terminate tozalashni (finally, with) bajarmaydi

=== 4. Ishga tushirish usuli ===
  joriy usul: spawn
  mavjud usullar: ['spawn']
  yadrolar: True
  ⭐ spawn/forkserver da bola modulni qayta import qiladi —
     shuning uchun butun ishga tushirish kodi if __name__ == '__main__' ichida

"""Nima uzatiladi va nima uzatilmaydi; lambda va ichki funksiya xatosi; partial; dataclass; fayl obyekti."""

import functools
import io
import multiprocessing as mp
import pickle
from dataclasses import dataclass


@dataclass(frozen=True, slots=True)
class Vazifa:
    id: int
    nom: str


def modul_funksiyasi(x: int) -> int:
    return x * 2


def koeffitsient_bilan(x: int, koeffitsient: int = 3) -> int:
    return x * koeffitsient


def bajar(funksiya, qiymat, navbat: mp.Queue) -> None:
    navbat.put(funksiya(qiymat))


def main() -> None:
    print("=== 1. Nima pickle qilinadi ===")
    ichki = lambda x: x * 2          # noqa: E731 — namuna uchun

    def ichki_funksiya(x: int) -> int:
        return x * 2

    namunalar = [
        ("modul funksiyasi", modul_funksiyasi),
        ("lambda", ichki),
        ("ichki funksiya", ichki_funksiya),
        ("partial", functools.partial(koeffitsient_bilan, koeffitsient=5)),
        ("dataclass", Vazifa(1, "hisobot")),
        ("ro'yxat", [1, 2, 3]),
        ("fayl obyekti", io.StringIO("matn")),
        ("qulf (threading)", __import__("threading").Lock()),
    ]
    for tavsif, obyekt in namunalar:
        try:
            pickle.dumps(obyekt)
            holat = "✅ uzatiladi"
        except Exception as xato:
            holat = f"❌ {type(xato).__name__}"
        print(f"  {tavsif:22} {holat}")

    print("\n=== 2. Jarayonga uzatish ===")
    navbat: mp.Queue = mp.Queue()
    jarayon = mp.Process(target=bajar, args=(modul_funksiyasi, 21, navbat))
    jarayon.start()
    print(f"  modul funksiyasi bilan: {navbat.get(timeout=15)}")
    jarayon.join(timeout=15)

    partial_funksiya = functools.partial(koeffitsient_bilan, koeffitsient=5)
    jarayon = mp.Process(target=bajar, args=(partial_funksiya, 4, navbat))
    jarayon.start()
    print(f"  partial bilan: {navbat.get(timeout=15)}")
    jarayon.join(timeout=15)

    print("\n=== 3. lambda bilan nima bo'ladi ===")
    try:
        pickle.dumps(ichki)
    except Exception as xato:
        print(f"  pickle.dumps(lambda) → {type(xato).__name__}: {str(xato)[:60]}")
    print("  ⚠️ spawn rejimida bunday target bilan Process.start() xato beradi")
    print("  ✅ yechim: modul darajasidagi funksiya yoki functools.partial")

    print("\n=== 4. Dataclass uzatish ===")
    vazifalar = [Vazifa(i, f"vazifa-{i}") for i in range(3)]
    kirish: mp.Queue = mp.Queue()
    for v in vazifalar:
        kirish.put(v)
    olingan = [kirish.get(timeout=5) for _ in vazifalar]
    print(f"  {len(olingan)} vazifa navbat orqali o'tdi: {olingan[0]}")
    print(f"  nusxalar teng, lekin boshqa obyektlar: {olingan[0] == vazifalar[0]}, {olingan[0] is vazifalar[0]}")


if __name__ == "__main__":
    main()

=== 1. Nima pickle qilinadi ===
  modul funksiyasi       ✅ uzatiladi
  lambda                 ❌ PicklingError
  ichki funksiya         ❌ PicklingError
  partial                ✅ uzatiladi
  dataclass              ✅ uzatiladi
  ro'yxat                ✅ uzatiladi
  fayl obyekti           ✅ uzatiladi
  qulf (threading)       ❌ TypeError

=== 2. Jarayonga uzatish ===
  modul funksiyasi bilan: 42
  partial bilan: 20

=== 3. lambda bilan nima bo'ladi ===
  pickle.dumps(lambda) → PicklingError: Can't pickle local object <function main.<locals>.<lambda> a
  ⚠️ spawn rejimida bunday target bilan Process.start() xato beradi
  ✅ yechim: modul darajasidagi funksiya yoki functools.partial

=== 4. Dataclass uzatish ===
  3 vazifa navbat orqali o'tdi: Vazifa(id=0, nom='vazifa-0')
  nusxalar teng, lekin boshqa obyektlar: True, False

"""Queue; Pipe; Value va Lock; shared_memory (nusxasiz); Manager; qaysi biri qachon."""

import multiprocessing as mp
import time
from multiprocessing import shared_memory


def navbat_ishchisi(kirish: mp.Queue, chiqish: mp.Queue) -> None:
    while True:
        vazifa = kirish.get()
        if vazifa is None:
            return
        chiqish.put(vazifa * vazifa)


def pipe_ishchisi(ulanish) -> None:
    xabar = ulanish.recv()
    ulanish.send(f"javob: {xabar.upper()}")
    ulanish.close()


def qoshuvchi(hisoblagich, qulf, marta: int) -> None:
    for _ in range(marta):
        with qulf:
            hisoblagich.value += 1


def qulfsiz_qoshuvchi(hisoblagich, marta: int) -> None:
    for _ in range(marta):
        hisoblagich.value += 1


def shm_ishchisi(nom: str, boshlanish: int, oxir: int) -> None:
    shm = shared_memory.SharedMemory(name=nom)
    for i in range(boshlanish, oxir):
        shm.buf[i] = (i * 7) % 256
    shm.close()


def manager_ishchisi(umumiy_lugat, kalit: int) -> None:
    umumiy_lugat[kalit] = kalit * kalit


def main() -> None:
    print("=== 1. Queue ===")
    kirish: mp.Queue = mp.Queue()
    chiqish: mp.Queue = mp.Queue()
    ishchilar = [mp.Process(target=navbat_ishchisi, args=(kirish, chiqish)) for _ in range(3)]
    for i in ishchilar:
        i.start()
    for n in range(12):
        kirish.put(n)
    natijalar = [chiqish.get(timeout=20) for _ in range(12)]
    for _ in ishchilar:
        kirish.put(None)
    for i in ishchilar:
        i.join(timeout=15)
    print(f"  12 vazifa, natijalar yig'indisi: {sum(natijalar)} (kutilgan {sum(n * n for n in range(12))})")
    print(f"  ishchilar to'xtadi: {all(not i.is_alive() for i in ishchilar)}")

    print("\n=== 2. Pipe ===")
    ota_uchi, bola_uchi = mp.Pipe()
    jarayon = mp.Process(target=pipe_ishchisi, args=(bola_uchi,))
    jarayon.start()
    ota_uchi.send("salom")
    print(f"  javob: {ota_uchi.recv()}")
    jarayon.join(timeout=15)

    print("\n=== 3. Value va Lock ===")
    hisoblagich = mp.Value("i", 0)
    qulf = mp.Lock()
    MARTA, ISHCHILAR = 20_000, 4
    jarayonlar = [mp.Process(target=qoshuvchi, args=(hisoblagich, qulf, MARTA)) for _ in range(ISHCHILAR)]
    for j in jarayonlar:
        j.start()
    for j in jarayonlar:
        j.join(timeout=60)
    print(f"  qulf bilan: {hisoblagich.value:,} — kutilgan {ISHCHILAR * MARTA:,}: {hisoblagich.value == ISHCHILAR * MARTA}")

    qulfsiz = mp.Value("i", 0)
    jarayonlar = [mp.Process(target=qulfsiz_qoshuvchi, args=(qulfsiz, MARTA)) for _ in range(ISHCHILAR)]
    for j in jarayonlar:
        j.start()
    for j in jarayonlar:
        j.join(timeout=60)
    print(f"  qulfsiz: yo'qotish bo'ldi: {qulfsiz.value < ISHCHILAR * MARTA}")
    print("  ⭐ jarayonlarda ham poyga holati bor — umumiy xotira umumiy holat demakdir")

    print("\n=== 4. shared_memory: nusxasiz ===")
    HAJM = 400
    shm = shared_memory.SharedMemory(create=True, size=HAJM)
    try:
        bolaklar = [(0, 100), (100, 200), (200, 300), (300, 400)]
        jarayonlar = [mp.Process(target=shm_ishchisi, args=(shm.name, a, b)) for a, b in bolaklar]
        for j in jarayonlar:
            j.start()
        for j in jarayonlar:
            j.join(timeout=20)
        kutilgan = bytes((i * 7) % 256 for i in range(HAJM))
        print(f"  {HAJM} bayt to'ldirildi, to'g'ri: {bytes(shm.buf[:HAJM]) == kutilgan}")
        print(f"  ma'lumot nusxalanmadi — jarayonlar bir xil xotiraga yozdi")
    finally:
        shm.close()
        shm.unlink()

    print("\n=== 5. Manager: qulay, lekin sekin ===")
    with mp.Manager() as menejer:
        umumiy = menejer.dict()
        jarayonlar = [mp.Process(target=manager_ishchisi, args=(umumiy, i)) for i in range(4)]
        for j in jarayonlar:
            j.start()
        for j in jarayonlar:
            j.join(timeout=20)
        print(f"  umumiy lug'at: {dict(sorted(umumiy.items()))}")
        bosh = time.perf_counter()
        for i in range(2_000):
            umumiy[i % 10] = i
        manager_vaqti = time.perf_counter() - bosh
    oddiy = {}
    bosh = time.perf_counter()
    for i in range(2_000):
        oddiy[i % 10] = i
    oddiy_vaqti = time.perf_counter() - bosh
    print(f"  2 000 yozuv: Manager oddiy dict dan kamida 10 barobar sekin: {manager_vaqti / oddiy_vaqti >= 10}")
    print("  ⭐ har amal jarayonlararo aloqa — issiq siklda ishlatmang")


if __name__ == "__main__":
    main()

=== 1. Queue ===
  12 vazifa, natijalar yig'indisi: 506 (kutilgan 506)
  ishchilar to'xtadi: True

=== 2. Pipe ===
  javob: javob: SALOM

=== 3. Value va Lock ===
  qulf bilan: 80,000 — kutilgan 80,000: True
  qulfsiz: yo'qotish bo'ldi: True
  ⭐ jarayonlarda ham poyga holati bor — umumiy xotira umumiy holat demakdir

=== 4. shared_memory: nusxasiz ===
  400 bayt to'ldirildi, to'g'ri: True
  ma'lumot nusxalanmadi — jarayonlar bir xil xotiraga yozdi

=== 5. Manager: qulay, lekin sekin ===
  umumiy lug'at: {0: 0, 1: 1, 2: 4, 3: 9}
  2 000 yozuv: Manager oddiy dict dan kamida 10 barobar sekin: True
  ⭐ har amal jarayonlararo aloqa — issiq siklda ishlatmang

"""Bo'laklash; Queue va shared_memory variantlari; xatolarni otaga yetkazish; vaqt va to'g'rilik."""

import multiprocessing as mp
import time
from multiprocessing import shared_memory

ELEMENTLAR = 400_000
BOLAKLAR = 4


def ogir_hisob(qiymatlar: list[int]) -> int:
    """Sof Python hisob — GIL tufayli iplar yordam bermaydi (12.6-dars)."""
    jami = 0
    for q in qiymatlar:
        jami += (q * q) % 97
    return jami


def queue_ishchisi(bolak: list[int], nomer: int, natijalar: mp.Queue) -> None:
    try:
        natijalar.put(("ok", nomer, ogir_hisob(bolak)))
    except Exception as xato:                      # noqa: BLE001 — xatoni otaga yetkazamiz
        natijalar.put(("xato", nomer, f"{type(xato).__name__}: {xato}"))


def shm_ishchisi(nom: str, boshlanish: int, oxir: int, nomer: int, natijalar: mp.Queue) -> None:
    shm = shared_memory.SharedMemory(name=nom)
    try:
        jami = 0
        for i in range(boshlanish, oxir):
            q = shm.buf[i]
            jami += (q * q) % 97
        natijalar.put(("ok", nomer, jami))
    except Exception as xato:                      # noqa: BLE001
        natijalar.put(("xato", nomer, f"{type(xato).__name__}: {xato}"))
    finally:
        shm.close()


def yiqiluvchi_ishchi(bolak: list[int], nomer: int, natijalar: mp.Queue) -> None:
    try:
        raise ValueError("ma'lumot buzilgan")
    except Exception as xato:                      # noqa: BLE001
        natijalar.put(("xato", nomer, f"{type(xato).__name__}: {xato}"))


def yig(natijalar: mp.Queue, soni: int, muddat: float = 60.0) -> tuple[int, list[str]]:
    jami, xatolar = 0, []
    for _ in range(soni):
        holat, nomer, qiymat = natijalar.get(timeout=muddat)
        if holat == "ok":
            jami += qiymat
        else:
            xatolar.append(f"bo'lak {nomer}: {qiymat}")
    return jami, xatolar


def main() -> None:
    malumot = [(i * 13) % 256 for i in range(ELEMENTLAR)]
    kutilgan = ogir_hisob(malumot)

    print("=== 1. Ketma-ket asos ===")
    bosh = time.perf_counter()
    ogir_hisob(malumot)
    ketma_ket = time.perf_counter() - bosh
    print(f"  {ELEMENTLAR:,} element, natija: {kutilgan}")

    print("\n=== 2. Queue orqali (ma'lumot nusxalanadi) ===")
    bolaklar = [malumot[i::BOLAKLAR] for i in range(BOLAKLAR)]
    natijalar: mp.Queue = mp.Queue()
    bosh = time.perf_counter()
    jarayonlar = [mp.Process(target=queue_ishchisi, args=(b, i, natijalar)) for i, b in enumerate(bolaklar)]
    for j in jarayonlar:
        j.start()
    jami, xatolar = yig(natijalar, BOLAKLAR)
    for j in jarayonlar:
        j.join(timeout=60)
    queue_vaqti = time.perf_counter() - bosh
    print(f"  natija to'g'ri: {jami == kutilgan}, xatolar: {len(xatolar)}")
    print(f"  exitcode lar: {[j.exitcode for j in jarayonlar]}")

    print("\n=== 3. shared_memory orqali (nusxasiz) ===")
    shm = shared_memory.SharedMemory(create=True, size=ELEMENTLAR)
    try:
        shm.buf[:ELEMENTLAR] = bytes(malumot)
        chegara = ELEMENTLAR // BOLAKLAR
        natijalar2: mp.Queue = mp.Queue()
        bosh = time.perf_counter()
        jarayonlar = [
            mp.Process(target=shm_ishchisi, args=(shm.name, i * chegara, (i + 1) * chegara, i, natijalar2))
            for i in range(BOLAKLAR)
        ]
        for j in jarayonlar:
            j.start()
        jami2, xatolar2 = yig(natijalar2, BOLAKLAR)
        for j in jarayonlar:
            j.join(timeout=60)
        shm_vaqti = time.perf_counter() - bosh
        print(f"  natija to'g'ri: {jami2 == kutilgan}, xatolar: {len(xatolar2)}")
    finally:
        shm.close()
        shm.unlink()

    print("\n=== 4. Vaqtlar ===")
    print(f"  jarayonlar ketma-ketdan tez (Queue): {queue_vaqti < ketma_ket}")
    print(f"  jarayonlar ketma-ketdan tez (shared_memory): {shm_vaqti < ketma_ket}")
    print(f"  shared_memory Queue dan tez yoki teng: {shm_vaqti <= queue_vaqti * 1.2}")
    print("  ⭐ ma'lumot qancha katta bo'lsa, nusxalash narxi shuncha sezilarli")

    print("\n=== 5. Xatolar otaga yetkaziladi ===")
    natijalar3: mp.Queue = mp.Queue()
    jarayonlar = [mp.Process(target=yiqiluvchi_ishchi, args=(bolaklar[0], i, natijalar3)) for i in range(2)]
    for j in jarayonlar:
        j.start()
    jami3, xatolar3 = yig(natijalar3, 2)
    for j in jarayonlar:
        j.join(timeout=30)
    print(f"  qaytgan xatolar: {len(xatolar3)}")
    print(f"  birinchisi: {xatolar3[0]}")
    print(f"  jarayonlar normal tugadi (exitcode 0): {all(j.exitcode == 0 for j in jarayonlar)}")
    print("  ⭐ xatoni ushlab, natija sifatida qaytarish — ota uni ko'radi va qaror qabul qiladi")


if __name__ == "__main__":
    main()

=== 1. Ketma-ket asos ===
  400,000 element, natija: 19292352

=== 2. Queue orqali (ma'lumot nusxalanadi) ===
  natija to'g'ri: True, xatolar: 0
  exitcode lar: [0, 0, 0, 0]

=== 3. shared_memory orqali (nusxasiz) ===
  natija to'g'ri: True, xatolar: 0

=== 4. Vaqtlar ===
  jarayonlar ketma-ketdan tez (Queue): False
  jarayonlar ketma-ketdan tez (shared_memory): False
  shared_memory Queue dan tez yoki teng: True
  ⭐ ma'lumot qancha katta bo'lsa, nusxalash narxi shuncha sezilarli

=== 5. Xatolar otaga yetkaziladi ===
  qaytgan xatolar: 2
  birinchisi: bo'lak 0: ValueError: ma'lumot buzilgan
  jarayonlar normal tugadi (exitcode 0): True
  ⭐ xatoni ushlab, natija sifatida qaytarish — ota uni ko'radi va qaror qabul qiladi

p = mp.Process(target=f); p.start()      # ❌ spawn: cheksiz ko'payish
if __name__ == "__main__": main()        # ✅

mp.Process(target=lambda: ishla())       # ❌ PicklingError
mp.Process(target=ishla)                 # ✅

for p in jarayonlar: p.join()            # ❌ navbat to'lgan bo'lsa — deadlock
natijalar = [q.get() for _ in ...]       # ✅ avval get
for p in jarayonlar: p.join()

ex.map(ishla, [(butun_massiv, i) for i in ...])   # ❌ har safar nusxa
shm = SharedMemory(...)                            # ✅ yoki fayl

v.value += 1                             # ❌ poyga holati
with qulf: v.value += 1                  # ✅

shm = SharedMemory(create=True, size=n)  # ⚠️ unlink qilinmasa, tizimda qoladi
try: ...
finally: shm.close(); shm.unlink()       # ✅

p.join()                                 # ⚠️ exitcode tekshirilmadi
if p.exitcode != 0: qayd_qil(...)        # ✅

mp.Process(target=kichik_funksiya)       # ⚠️ yaratish narxi ishdan qimmat (12.6-dars)

import multiprocessing as mp
import os
1.  print(mp.cpu_count() >= 1)
2.  print(mp.get_start_method() in {"spawn", "fork", "forkserver"})
3.  print(type(mp.Queue()).__name__)
4.  q = mp.Queue()
    q.put(5)
    print(q.get(timeout=5))
5.  v = mp.Value("i", 7)
    print(v.value)
6.  v.value += 1
    print(v.value)
7.  a = mp.Array("i", [1, 2, 3])
    print(list(a))
8.  p = mp.Process(target=print, args=("salom",))
    print(p.exitcode, p.is_alive())
9.  ota, bola = mp.Pipe()
    ota.send([1, 2])
    print(bola.recv())
10. print(mp.current_process().name)
11. import pickle
    try:
        pickle.dumps(lambda: 1)
    except Exception as e:
        print(type(e).__name__)
12. print(os.getpid() == mp.current_process().pid)

1.  # skript.py
    p = mp.Process(target=ishla)
    p.start()
    p.join()

2.  mp.Process(target=lambda x: x * 2, args=(5,)).start()

3.  jarayonlar = [mp.Process(target=ishchi, args=(q,)) for _ in range(4)]
    for p in jarayonlar: p.start()
    for p in jarayonlar: p.join()
    natijalar = [q.get() for _ in range(4)]

4.  v = mp.Value("i", 0)
    def oshir():
        for _ in range(10000):
            v.value += 1

5.  shm = shared_memory.SharedMemory(create=True, size=1_000_000)
    ishla(shm.name)
    # dastur tugaydi