14.5-dars: Pool va concurrent.futures

with cf.ProcessPoolExecutor(max_workers=4) as ex:
    kelajak = ex.submit(ishla, x)             # bitta vazifa → Future
    natijalar = list(ex.map(ishla, malumot, chunksize=100))

cf.as_completed(kelajaklar, timeout=30)                  # tugash tartibida
tugagan, qolgan = cf.wait(kelajaklar, timeout=5, return_when=cf.FIRST_COMPLETED)

with mp.Pool(processes=4, initializer=boshlash, initargs=(sozlama,), maxtasksperchild=100) as pul:
    natijalar = pul.map(ishla, malumot, chunksize=50)
    tartibsiz = pul.imap_unordered(ishla, malumot)        # tayyor bo'lgani chiqadi
    bitta = pul.apply_async(ishla, (x,), error_callback=qayd)

def boshlash(yol: str) -> None:
    global MODEL
    MODEL = ogir_model_yukla(yol)          # har vazifada emas, bir marta

ex.shutdown(wait=True)                       # hammasi tugaguncha kutadi (with ning sukuti)
ex.shutdown(wait=False, cancel_futures=True) # navbatdagilarni bekor qiladi

import concurrent.futures as cf

with cf.ProcessPoolExecutor(max_workers=4) as ex:
    for kelajak in cf.as_completed({ex.submit(ishla, x): x for x in malumot}):
        natija = kelajak.result()            # istisno shu yerda

with mp.Pool(4, initializer=boshlash, maxtasksperchild=100) as pul:
    for natija in pul.imap_unordered(ishla, malumot, chunksize=50):
        ...

har Future natijasini o'qing
chunksize: mayda vazifa → katta paket
initializer: og'ir tayyorgarlik bir marta
shutdown(cancel_futures=True): navbatdagilarni bekor qiladi
timeout vazifani to'xtatmaydi

"""submit va map; Future holatlari; as_completed va wait; cancel; iplar va jarayonlar bitta API bilan."""

import concurrent.futures as cf
import time


def sekin_kvadrat(x: int) -> int:
    time.sleep(0.05)
    return x * x


def uzoq_kvadrat(x: int) -> int:
    time.sleep(0.3)
    return x * x


def main() -> None:
    print("=== 1. map va submit ===")
    with cf.ThreadPoolExecutor(max_workers=4) as ex:
        natijalar = list(ex.map(sekin_kvadrat, range(8)))
        kelajak = ex.submit(sekin_kvadrat, 10)
        print(f"  map natijalari (tartibda): {natijalar}")
        print(f"  submit → {type(kelajak).__name__}, natija: {kelajak.result(timeout=10)}")

    print("\n=== 2. Future holatlari ===")
    with cf.ThreadPoolExecutor(max_workers=1) as ex:
        birinchi = ex.submit(uzoq_kvadrat, 1)
        ikkinchi = ex.submit(uzoq_kvadrat, 2)           # navbatda kutadi
        time.sleep(0.05)
        print(f"  birinchi: running={birinchi.running()}, done={birinchi.done()}")
        print(f"  ikkinchi navbatda: running={ikkinchi.running()}, cancel() → {ikkinchi.cancel()}")
        print(f"  bekor qilingandan keyin: cancelled={ikkinchi.cancelled()}")
        print(f"  birinchi natijasi: {birinchi.result(timeout=10)}")
        print(f"  ishlayotgan vazifani bekor qilib bo'lmaydi: {birinchi.cancel()}")

    print("\n=== 3. as_completed: tugash tartibida ===")

    def turli_vaqt(x: int) -> tuple[int, float]:
        kutish = 0.05 * (5 - x)
        time.sleep(kutish)
        return x, kutish

    with cf.ThreadPoolExecutor(max_workers=5) as ex:
        kelajaklar = [ex.submit(turli_vaqt, i) for i in range(5)]
        tartib = [kelajak.result()[0] for kelajak in cf.as_completed(kelajaklar, timeout=10)]
    print(f"  yuborilish tartibi: {list(range(5))}")
    print(f"  tugash tartibi:     {tartib}  ← eng qisqa kutgani birinchi")

    print("\n=== 4. wait ===")
    with cf.ThreadPoolExecutor(max_workers=4) as ex:
        kelajaklar = [ex.submit(sekin_kvadrat, i) for i in range(4)]
        tugagan, qolgan = cf.wait(kelajaklar, timeout=0.01, return_when=cf.FIRST_COMPLETED)
        print(f"  10 ms dan keyin: tugagan {len(tugagan)}, qolgan {len(qolgan)}")
        tugagan, qolgan = cf.wait(kelajaklar, timeout=10, return_when=cf.ALL_COMPLETED)
        print(f"  kutgandan keyin: tugagan {len(tugagan)}, qolgan {len(qolgan)}")

    print("\n=== 5. Bitta API, uch xil ishchi ===")
    pullar = {
        "iplar": cf.ThreadPoolExecutor(max_workers=4),
        "jarayonlar": cf.ProcessPoolExecutor(max_workers=4),
        "subinterpretatorlar": cf.InterpreterPoolExecutor(max_workers=4),
    }
    for nom, ex in pullar.items():
        with ex:
            natija = list(ex.map(sekin_kvadrat, range(4)))
        print(f"  {nom:22} {natija}")
    print("  ⭐ kod bir xil — faqat Executor klassi almashadi")


if __name__ == "__main__":
    main()

=== 1. map va submit ===
  map natijalari (tartibda): [0, 1, 4, 9, 16, 25, 36, 49]
  submit → Future, natija: 100

=== 2. Future holatlari ===
  birinchi: running=True, done=False
  ikkinchi navbatda: running=False, cancel() → True
  bekor qilingandan keyin: cancelled=True
  birinchi natijasi: 1
  ishlayotgan vazifani bekor qilib bo'lmaydi: False

=== 3. as_completed: tugash tartibida ===
  yuborilish tartibi: [0, 1, 2, 3, 4]
  tugash tartibi:     [4, 3, 2, 1, 0]  ← eng qisqa kutgani birinchi

=== 4. wait ===
  10 ms dan keyin: tugagan 0, qolgan 4
  kutgandan keyin: tugagan 4, qolgan 0

=== 5. Bitta API, uch xil ishchi ===
  iplar                  [0, 1, 4, 9]
  jarayonlar             [0, 1, 4, 9]
  subinterpretatorlar    [0, 1, 4, 9]
  ⭐ kod bir xil — faqat Executor klassi almashadi

"""Istisnolar Future ichida; map va as_completed farqi; timeout vazifani to'xtatmaydi; shutdown(cancel_futures)."""

import concurrent.futures as cf
import time

BAJARILGANLAR: list[int] = []


def beqaror(x: int) -> int:
    if x % 4 == 3:
        raise ValueError(f"x={x} ishlov bermaydi")
    time.sleep(0.02)
    return x * 10


def juda_sekin(x: int) -> int:
    time.sleep(0.5)
    BAJARILGANLAR.append(x)
    return x


def main() -> None:
    print("=== 1. Istisno Future ichida ===")
    with cf.ThreadPoolExecutor(max_workers=4) as ex:
        yaxshi, yomon = ex.submit(beqaror, 1), ex.submit(beqaror, 3)
        print(f"  yaxshi natija: {yaxshi.result(timeout=5)}")
        print(f"  yomon exception(): {type(yomon.exception(timeout=5)).__name__}")
        try:
            yomon.result()
        except ValueError as xato:
            print(f"  yomon result(): ValueError: {xato}")

    print("\n=== 2. map: birinchi xatoda to'xtaydi ===")
    with cf.ThreadPoolExecutor(max_workers=4) as ex:
        olingan = []
        try:
            for natija in ex.map(beqaror, range(8)):
                olingan.append(natija)
        except ValueError as xato:
            print(f"  {len(olingan)} natija olindi, keyin: {xato}")

    print("\n=== 3. as_completed: hammasi ko'riladi ===")
    with cf.ThreadPoolExecutor(max_workers=4) as ex:
        kelajaklar = {ex.submit(beqaror, i): i for i in range(8)}
        natijalar, xatolar = [], []
        for kelajak in cf.as_completed(kelajaklar, timeout=10):
            try:
                natijalar.append(kelajak.result())
            except ValueError:
                xatolar.append(kelajaklar[kelajak])
    print(f"  muvaffaqiyatli: {len(natijalar)}, xato bergan qiymatlar: {sorted(xatolar)}")
    print("  ⭐ hamma vazifa bajarildi va har biri hisobga olindi")

    print("\n=== 4. ⚠️ timeout vazifani to'xtatmaydi ===")
    BAJARILGANLAR.clear()
    with cf.ThreadPoolExecutor(max_workers=2) as ex:
        kelajak = ex.submit(juda_sekin, 1)
        try:
            kelajak.result(timeout=0.05)
        except TimeoutError:
            print("  result(timeout=0.05) → TimeoutError")
        print(f"  lekin vazifa hali ishlayapti: {not kelajak.done()}")
    print(f"  with blokidan chiqishda kutildi va bajarildi: {BAJARILGANLAR == [1]}")

    print("\n=== 5. shutdown(cancel_futures=True) ===")
    ex = cf.ThreadPoolExecutor(max_workers=2)
    kelajaklar = [ex.submit(beqaror, i) for i in (0, 1, 2, 4, 5, 6, 8, 9, 10, 12)]
    ex.shutdown(wait=True, cancel_futures=True)
    bekor = sum(k.cancelled() for k in kelajaklar)
    bajarilgan = sum(k.done() and not k.cancelled() for k in kelajaklar)
    print(f"  har vazifa yo bajarildi, yo bekor qilindi: {bajarilgan + bekor == len(kelajaklar)}")
    print(f"  ko'pchiligi bekor qilindi: {bekor >= 5}")
    print(f"  ishlab ulgurganlari bekor qilinmadi: {bajarilgan >= 1}")
    print("  ⭐ cancel_futures faqat navbatda turganlarga ta'sir qiladi")


if __name__ == "__main__":
    main()

=== 1. Istisno Future ichida ===
  yaxshi natija: 10
  yomon exception(): ValueError
  yomon result(): ValueError: x=3 ishlov bermaydi

=== 2. map: birinchi xatoda to'xtaydi ===
  3 natija olindi, keyin: x=3 ishlov bermaydi

=== 3. as_completed: hammasi ko'riladi ===
  muvaffaqiyatli: 6, xato bergan qiymatlar: [3, 7]
  ⭐ hamma vazifa bajarildi va har biri hisobga olindi

=== 4. ⚠️ timeout vazifani to'xtatmaydi ===
  result(timeout=0.05) → TimeoutError
  lekin vazifa hali ishlayapti: True
  with blokidan chiqishda kutildi va bajarildi: True

=== 5. shutdown(cancel_futures=True) ===
  har vazifa yo bajarildi, yo bekor qilindi: True
  ko'pchiligi bekor qilindi: True
  ishlab ulgurganlari bekor qilinmadi: True
  ⭐ cancel_futures faqat navbatda turganlarga ta'sir qiladi

"""map, imap, imap_unordered, starmap, apply_async; initializer; maxtasksperchild; chunksize ta'siri."""

import multiprocessing as mp
import os
import time

ISHCHI_HOLATI: dict[str, object] = {}


def boshlash(nom: str) -> None:
    """Har ishchi jarayonda bir marta bajariladi."""
    ISHCHI_HOLATI["nom"] = f"{nom}-{os.getpid()}"
    ISHCHI_HOLATI["chaqirilgan"] = int(ISHCHI_HOLATI.get("chaqirilgan", 0)) + 1


def holat_ol(_: int) -> tuple[str, int]:
    return (
        str(ISHCHI_HOLATI.get("nom", "tayyorlanmagan")),
        int(ISHCHI_HOLATI.get("chaqirilgan", 0)),
    )


def kvadrat(x: int) -> int:
    return x * x


def juft_kopaytir(a: int, b: int) -> int:
    return a * b


def mayda(x: int) -> int:
    return x + 1


def pid_ol(_: int) -> int:
    return os.getpid()


def xatoli(x: int) -> int:
    if x == 3:
        raise ValueError("uchinchi element buzilgan")
    return x


def main() -> None:
    print("=== 1. map, imap, imap_unordered ===")
    with mp.Pool(processes=3) as pul:
        print(f"  map:             {pul.map(kvadrat, range(6))}")
        print(f"  imap (tartibda): {list(pul.imap(kvadrat, range(6)))}")
        tartibsiz = list(pul.imap_unordered(kvadrat, range(6)))
        print(f"  imap_unordered:  to'plam bir xil: {sorted(tartibsiz) == [x * x for x in range(6)]}")
        print(f"  starmap:         {pul.starmap(juft_kopaytir, [(2, 3), (4, 5), (6, 7)])}")

    print("\n=== 2. initializer ===")
    with mp.Pool(processes=3, initializer=boshlash, initargs=("ishchi",)) as pul:
        holatlar = pul.map(holat_ol, range(12))
    nomlar = {nom for nom, _ in holatlar}
    chaqiruvlar = {son for _, son in holatlar}
    print(f"  12 vazifa bajarildi, hammasi tayyorlangan ishchida: {'tayyorlanmagan' not in nomlar}")
    print(f"  har ishchida initializer aynan bir marta chaqirilgan: {chaqiruvlar == {1}}")
    print(f"  ishchi nomlari soni 3 tadan oshmaydi: {len(nomlar) <= 3}")
    print(f"  asosiy jarayonda holat bo'sh: {ISHCHI_HOLATI == {}}")

    print("\n=== 3. apply_async va xatolar ===")
    with mp.Pool(processes=2) as pul:
        natija = pul.apply_async(kvadrat, (9,))
        print(f"  apply_async: {natija.get(timeout=20)}, tayyor: {natija.ready()}")
        xato_natija = pul.apply_async(xatoli, (3,))
        try:
            xato_natija.get(timeout=20)
        except ValueError as xato:
            print(f"  xatoli vazifa: ValueError: {xato}")
        try:
            pul.map(xatoli, range(6))
        except ValueError as xato:
            print(f"  map birinchi xatoda to'xtaydi: {xato}")

    print("\n=== 4. maxtasksperchild ===")
    with mp.Pool(processes=2, maxtasksperchild=2) as pul:
        pidlar = pul.map(pid_ol, range(8), chunksize=1)
    print(f"  8 vazifa, 2 ishchi, maxtasksperchild=2 → PID lar soni 2 dan ko'p: {len(set(pidlar)) > 2}")
    print(f"  har PID ko'pi bilan 2 vazifa bajargan: {max(pidlar.count(p) for p in set(pidlar)) <= 2}")
    print("  ⭐ xotira sizishiga qarshi himoya")

    print("\n=== 5. chunksize ta'siri ===")
    MAYDA = list(range(200_000))
    with mp.Pool(processes=4) as pul:
        bosh = time.perf_counter()
        pul.map(mayda, MAYDA, chunksize=1)
        kichik = time.perf_counter() - bosh
        bosh = time.perf_counter()
        pul.map(mayda, MAYDA, chunksize=10_000)
        katta = time.perf_counter() - bosh
    print(f"  chunksize=10 000 chunksize=1 dan kamida 3 barobar tez: {kichik / katta >= 3}")
    print("  ⭐ mayda vazifalarda uzatish narxi hal qiluvchi (12.6-dars)")


if __name__ == "__main__":
    main()

=== 1. map, imap, imap_unordered ===
  map:             [0, 1, 4, 9, 16, 25]
  imap (tartibda): [0, 1, 4, 9, 16, 25]
  imap_unordered:  to'plam bir xil: True
  starmap:         [6, 20, 42]

=== 2. initializer ===
  12 vazifa bajarildi, hammasi tayyorlangan ishchida: True
  har ishchida initializer aynan bir marta chaqirilgan: True
  ishchi nomlari soni 3 tadan oshmaydi: True
  asosiy jarayonda holat bo'sh: True

=== 3. apply_async va xatolar ===
  apply_async: 81, tayyor: True
  xatoli vazifa: ValueError: uchinchi element buzilgan
  map birinchi xatoda to'xtaydi: uchinchi element buzilgan

=== 4. maxtasksperchild ===
  8 vazifa, 2 ishchi, maxtasksperchild=2 → PID lar soni 2 dan ko'p: True
  har PID ko'pi bilan 2 vazifa bajargan: True
  ⭐ xotira sizishiga qarshi himoya

=== 5. chunksize ta'siri ===
  chunksize=10 000 chunksize=1 dan kamida 3 barobar tez: True
  ⭐ mayda vazifalarda uzatish narxi hal qiluvchi (12.6-dars)

"""initializer bilan tayyorgarlik; as_completed bilan yig'ish; xatolar hisoboti; iplar va jarayonlar solishtiruvi."""

import concurrent.futures as cf
import hashlib
import os
import time
from dataclasses import dataclass

HUJJATLAR = [f"hujjat-{i:04d}" for i in range(240)]
ISHCHILAR = 4
LUGAT: dict[str, int] = {}


@dataclass(frozen=True, slots=True)
class Tahlil:
    hujjat: str
    ball: int
    ishchi: int


def model_yukla() -> None:
    """Og'ir tayyorgarlik: har ishchida bir marta."""
    global LUGAT
    LUGAT = {f"soz{i}": i for i in range(20_000)}


def tahlil_qil(hujjat: str) -> Tahlil:
    if not LUGAT:
        raise RuntimeError("model yuklanmagan")
    if hujjat.endswith("13"):
        raise ValueError("buzilgan format")
    xesh = hashlib.sha256(hujjat.encode())
    for _ in range(300):
        xesh.update(b"x")
    ball = 0
    for _ in range(6):                       # sof Python hisob — GIL ni band qiladi
        ball = sum(LUGAT.get(f"soz{i}", 0) for i in range(0, 20_000, 3)) % 1000
    return Tahlil(hujjat, ball + xesh.digest()[0], os.getpid())


def quvur(Ex, ishchilar: int = ISHCHILAR) -> tuple[list[Tahlil], list[str], float]:
    bosh = time.perf_counter()
    natijalar: list[Tahlil] = []
    xatolar: list[str] = []
    with Ex(max_workers=ishchilar, initializer=model_yukla) as ex:
        kelajaklar = {ex.submit(tahlil_qil, h): h for h in HUJJATLAR}
        for kelajak in cf.as_completed(kelajaklar, timeout=300):
            hujjat = kelajaklar[kelajak]
            try:
                natijalar.append(kelajak.result())
            except ValueError as xato:
                xatolar.append(f"{hujjat}: {xato}")
    return natijalar, xatolar, time.perf_counter() - bosh


def main() -> None:
    print("=== 1. Jarayonlar puli ===")
    natijalar, xatolar, jarayon_vaqti = quvur(cf.ProcessPoolExecutor)
    print(f"  {len(HUJJATLAR)} hujjat: {len(natijalar)} tahlil, {len(xatolar)} xato")
    ishchilar = {t.ishchi for t in natijalar}
    print(f"  hammasi hisobga olindi: {len(natijalar) + len(xatolar) == len(HUJJATLAR)}")
    print(f"  bir nechta ishchi jarayon ishladi: {1 < len(ishchilar) <= 4}")
    print(f"  asosiy jarayon ishlatilmadi: {os.getpid() not in ishchilar}")
    print(f"  asosiy jarayonda LUGAT bo'sh qoldi: {len(LUGAT) == 0}")

    print("\n=== 2. Xatolar hisoboti ===")
    for xato in sorted(xatolar)[:3]:
        print(f"  {xato}")
    print(f"  jami: {len(xatolar)}")

    print("\n=== 3. Iplar bilan solishtirish ===")
    ip_natijalari, ip_xatolari, ip_vaqti = quvur(cf.ThreadPoolExecutor)
    print(f"  iplar: {len(ip_natijalari)} tahlil, {len(ip_xatolari)} xato")
    print(f"  natijalar mos: {sorted(t.hujjat for t in natijalar) == sorted(t.hujjat for t in ip_natijalari)}")
    print(f"  iplarda bitta jarayon: {len({t.ishchi for t in ip_natijalari}) == 1}")
    print(f"  jarayonlar iplardan kamida 2 barobar tez: {ip_vaqti / jarayon_vaqti >= 2}")
    print("  ⭐ sof Python hisob GIL ni band qiladi — iplar yordam bermaydi")

    print("\n=== 4. initializer nima berdi ===")
    print(f"  model har ishchida bir marta yuklandi (eng ko'pi bilan {ISHCHILAR} marta),")
    print(f"  har vazifada emas ({len(HUJJATLAR)} marta bo'lardi)")
    print(f"  iplar esa asosiy jarayon xotirasini to'ldirdi: {len(LUGAT) > 0}")
    print("  ⚠️ iplar bitta xotirani bo'lishadi — global holat ular uchun umumiy")

    print("\n=== 5. Qoidalar ===")
    print("  ✅ og'ir tayyorgarlik — initializer da")
    print("  ✅ natijalar as_completed bilan, har biri tekshiriladi")
    print("  ✅ xatolar hisobotga tushadi, quvur to'xtamaydi")
    print("  ✅ sof Python hisob — jarayonlar; I/O bo'lsa — iplar (14.8-dars)")


if __name__ == "__main__":
    main()

=== 1. Jarayonlar puli ===
  240 hujjat: 237 tahlil, 3 xato
  hammasi hisobga olindi: True
  bir nechta ishchi jarayon ishladi: True
  asosiy jarayon ishlatilmadi: True
  asosiy jarayonda LUGAT bo'sh qoldi: True

=== 2. Xatolar hisoboti ===
  hujjat-0013: buzilgan format
  hujjat-0113: buzilgan format
  hujjat-0213: buzilgan format
  jami: 3

=== 3. Iplar bilan solishtirish ===
  iplar: 237 tahlil, 3 xato
  natijalar mos: True
  iplarda bitta jarayon: True
  jarayonlar iplardan kamida 2 barobar tez: True
  ⭐ sof Python hisob GIL ni band qiladi — iplar yordam bermaydi

=== 4. initializer nima berdi ===
  model har ishchida bir marta yuklandi (eng ko'pi bilan 4 marta),
  har vazifada emas (240 marta bo'lardi)
  iplar esa asosiy jarayon xotirasini to'ldirdi: True
  ⚠️ iplar bitta xotirani bo'lishadi — global holat ular uchun umumiy

=== 5. Qoidalar ===
  ✅ og'ir tayyorgarlik — initializer da
  ✅ natijalar as_completed bilan, har biri tekshiriladi
  ✅ xatolar hisobotga tushadi, quvur to'xtamaydi
  ✅ sof Python hisob — jarayonlar; I/O bo'lsa — iplar (14.8-dars)

def ishlov(sorov):
    with ProcessPoolExecutor() as ex:     # ❌ har safar jarayonlar yaratiladi
        ...
POOL = ProcessPoolExecutor()              # ✅ bir marta

natijalar = list(ex.map(ishla, malumot))  # ⚠️ birinchi xatoda to'xtaydi
for k in as_completed(kelajaklar): ...    # ✅ hammasi hisobga olinadi

ex.map(mayda_funksiya, 1_000_000 * [...])            # ❌
ex.map(mayda_funksiya, malumot, chunksize=10_000)    # ✅

def vazifa(x):
    model = model_yukla()                 # ❌ har vazifada
ProcessPoolExecutor(initializer=model_yukla)   # ✅ har ishchida bir marta

ex.submit(ishla, x)                       # ❌ xato jim qoladi

# ⚠️ ishchi yiqilsa (segfault, OOM) — butun pul ishlamay qoladi
except cf.process.BrokenProcessPool:      # ✅ qayta yaratish yoki qayd qilish

def vazifa():
    return POOL.submit(boshqa).result()   # ⚠️ deadlock xavfi

ex.map(ishla, [(katta_jadval, i) for i in ...])   # ❌ (14.4-dars)

import concurrent.futures as cf
1.  with cf.ThreadPoolExecutor(2) as ex:
        print(list(ex.map(abs, [-1, -2, 3])))
2.  with cf.ThreadPoolExecutor(2) as ex:
        f = ex.submit(sum, [1, 2])
    print(f.result(), f.done(), f.cancelled())
3.  with cf.ThreadPoolExecutor(2) as ex:
        f = ex.submit(int, "x")
    print(type(f.exception()).__name__)
4.  with cf.ThreadPoolExecutor(1) as ex:
        a = ex.submit(sum, [1])
        b = ex.submit(sum, [2])
        print(b.cancel() in (True, False))
5.  print(cf.FIRST_COMPLETED, cf.ALL_COMPLETED)
6.  with cf.ThreadPoolExecutor(2) as ex:
        fs = [ex.submit(pow, 2, i) for i in range(3)]
        print(sorted(f.result() for f in cf.as_completed(fs)))
7.  with cf.ThreadPoolExecutor(2) as ex:
        t, q = cf.wait([ex.submit(pow, 2, 3)], timeout=5)
    print(len(t), len(q))
8.  print(hasattr(cf, "InterpreterPoolExecutor"))
9.  import multiprocessing as mp
    with mp.Pool(2) as p:
        print(p.map(abs, [-1, -2]))
10. with mp.Pool(2) as p:
        print(p.starmap(pow, [(2, 3)]))
11. with mp.Pool(2) as p:
        r = p.apply_async(abs, (-5,))
        print(r.get(timeout=10), r.ready())
12. with mp.Pool(2) as p:
        print(sorted(p.imap_unordered(abs, [-3, -1, -2])))

1.  def ishlov(sorovlar):
        with ProcessPoolExecutor() as ex:
            return list(ex.map(og_ir, sorovlar))

2.  natijalar = list(ex.map(tahlil, hujjatlar))   # ba'zi hujjatlar buzilgan

3.  ex.map(kichik_funksiya, range(1_000_000))

4.  def vazifa(x):
        model = katta_model_yukla()
        return model.bashorat(x)
    ex.map(vazifa, malumot)

5.  for x in malumot:
        ex.submit(saqla, x)
    print("saqlandi")