Lidsky řečeno
Představ si restauraci. Proces je samostatná kuchyně s vlastními zásobami. Vlákno je kuchař v té kuchyni, všichni kuchaři sdílejí stejnou lednici. V pythonní kuchyni je navíc jediný nůž a krájet může jen ten, kdo ho drží. To je GIL. Když kuchař čeká, až se uvaří voda, nůž odloží a krájí jiný, takže čekání se krásně překrývá. Když je ale práce samé krájení, víc kuchařů nepomůže. Potřebuješ další kuchyni.
Čekání, nebo počítání
Než sáhneš po čemkoli z téhle lekce, zjisti, co tvůj program vlastně dělá.
- Čeká na síť, disk nebo databázi. Procesor přitom skoro nepracuje. Říká se tomu úloha omezená vstupem a výstupem, zkráceně I/O.
- Počítá: komprimuje, šifruje, prochází velká data v Pythonu. Procesor jede naplno. To je úloha omezená CPU.
úloha pomůžou vlákna? pomůžou procesy?
čeká (I/O) ano ano, ale jsou zbytečně drahé
počítá (CPU) ne, kvůli GIL anoDvě slova, která se pletou: souběh znamená, že se víc úloh střídá a překrývá v čase. Paralelismus znamená, že běží doslova ve stejný okamžik na různých jádrech. Vlákna v Pythonu dávají souběh, procesy paralelismus.
První vlákna
Vlákno vytvoříš třídou threading.Thread. target je funkce, args její argumenty. start() vlákno rozběhne a hned se vrátí, join() počká na jeho konec.
import threading
import time
def stahni(soubor, vysledky):
time.sleep(0.2) # tady by bylo čekání na síť
vysledky[soubor] = len(soubor)
vysledky = {}
vlakna = [
threading.Thread(target=stahni, args=(s, vysledky))
for s in ("a.txt", "bb.txt", "ccc.txt")
]
zacatek = time.perf_counter()
for v in vlakna:
v.start()
for v in vlakna:
v.join()
trvani = time.perf_counter() - zacatek
print(sorted(vysledky.items()))
print("rychleji než postupně (0.6 s):", trvani < 0.5)
[('a.txt', 5), ('bb.txt', 6), ('ccc.txt', 7)]
rychleji než postupně (0.6 s): TrueTři čekání se překryla. V praxi vlákna ručně skoro nezakládej. ThreadPoolExecutor drží skupinu připravených vláken, rozděluje jim práci a předává výsledky i výjimky.
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
def zpracuj(n):
time.sleep(0.1 * (4 - n))
return n * n
with ThreadPoolExecutor(max_workers=3) as pool:
print(list(pool.map(zpracuj, [1, 2, 3])))
budouci = [pool.submit(zpracuj, n) for n in [1, 2, 3]]
print([f.result() for f in as_completed(budouci)])
chybna = pool.submit(lambda: 1 / 0)
try:
chybna.result()
except ZeroDivisionError as e:
print("chyba z vlákna:", e)
[1, 4, 9] [9, 4, 1] chyba z vlákna: division by zero
map vrací výsledky v pořadí vstupů, i když číslo 3 doběhlo první. submit vrátí objekt Future, slib budoucího výsledku, a as_completed je dává v pořadí dokončení. Výjimka se přenese až při volání result().
Souběhová chyba
Vlákna sdílejí paměť. To je jejich výhoda i největší nebezpečí. Vezmi obyčejné zvýšení čísla o jedna. Skládá se ze dvou kroků: přečíst a zapsat. Když se dvě vlákna prostřídají ve špatnou chvíli, jedno zvýšení se ztratí. Říká se tomu souběhová chyba (race condition).
Střídání si můžeš nasimulovat i bez vláken. Generátor z lekce Generátory a líné zpracování se na každém yield zastaví, takže přesně určíš, kdo je zrovna na řadě.
def pridej(jmeno, stav, log):
hodnota = stav["pocet"]
log.append(f"{jmeno} přečetl {hodnota}")
yield
stav["pocet"] = hodnota + 1
log.append(f"{jmeno} zapsal {hodnota + 1}")
def simuluj(poradi):
stav = {"pocet": 0}
log = []
ulohy = {j: pridej(j, stav, log) for j in "AB"}
for kdo in poradi:
next(ulohy[kdo], None)
return stav["pocet"], log
for poradi in ("AABB", "ABAB"):
vysledek, log = simuluj(poradi)
print(poradi, "->", vysledek)
print(" " + ", ".join(log))
AABB -> 2 A přečetl 0, A zapsal 1, B přečetl 1, B zapsal 2 ABAB -> 1 A přečetl 0, B přečetl 0, A zapsal 1, B zapsal 1
U pořadí AABB je vše v pořádku. U ABAB si obě úlohy přečetly nulu a obě zapsaly jedničku. Skutečná vlákna to umí také. Tady je Barrier, závora, která pustí vlákna dál až ve chvíli, kdy k ní dorazí všechna. Tím chybu vynutíme při každém spuštění, jinak by se objevovala náhodně, a to je na ní to nejhorší.
import threading
pocet = 0
zavora = threading.Barrier(2)
def pridej():
global pocet
hodnota = pocet
zavora.wait() # obě vlákna už mají přečtenou starou hodnotu
pocet = hodnota + 1
vlakna = [threading.Thread(target=pridej) for _ in range(2)]
for v in vlakna:
v.start()
for v in vlakna:
v.join()
print(pocet)
1
Lék je zámek. Čtení i zápis se zabalí do with zamek: a zámek drží vždy jen jedno vlákno, ostatní čekají. Úsek pod zámkem se proti ostatním chová jako jeden krok.
import threading
pocet = 0
zamek = threading.Lock()
def pridej(kolik):
global pocet
for _ in range(kolik):
with zamek:
pocet += 1
vlakna = [threading.Thread(target=pridej, args=(50_000,)) for _ in range(4)]
for v in vlakna:
v.start()
for v in vlakna:
v.join()
print(pocet)
200000
Zámek v simulaci
Scheduler spust střídá úlohy náhodně. Přepiš generátor pridej tak, aby neztratil žádné zvýšení. Použij simulovaný zámek stav["zamek"]: dokud je True, úloha čeká (yield v cyklu). Pak si ho nastaví na True, provede čtení a zápis a nakonec ho vrátí na False. Mezi čtením a zápisem nech yield, ať je simulace poctivá.
import random
def pridej(stav):
hodnota = stav["pocet"]
yield
stav["pocet"] = hodnota + 1
yield
def spust(pocet_uloh, seed):
nahoda = random.Random(seed)
stav = {"pocet": 0, "zamek": False}
ulohy = [pridej(stav) for _ in range(pocet_uloh)]
while ulohy:
u = nahoda.choice(ulohy)
try:
next(u)
except StopIteration:
ulohy.remove(u)
return stav["pocet"]
print(spust(5, 1))
Uváznutí
Zámky přinášejí vlastní problém. Vlákno 1 drží zámek A a chce B. Vlákno 2 drží B a chce A. Obě čekají navždy. Je to uváznutí (deadlock). Ukázka ho vynutí a z pasti uniká jen díky časovému limitu. Pravidlo, které mu předchází, je prosté: všechna vlákna berou zámky ve stejném pořadí.
import threading
a = threading.Lock()
b = threading.Lock()
zavora = threading.Barrier(2)
vysledky = {}
def prace(jmeno, prvni, druhy):
with prvni:
zavora.wait() # každé vlákno drží svůj první zámek
ziskal = druhy.acquire(timeout=0.2)
vysledky[jmeno] = ziskal
zavora.wait() # obě to už zkusila
if ziskal:
druhy.release()
def spust(cil_1, cil_2):
vlakna = [
threading.Thread(target=prace, args=("v1", *cil_1)),
threading.Thread(target=prace, args=("v2", *cil_2)),
]
for v in vlakna:
v.start()
for v in vlakna:
v.join()
spust((a, b), (b, a))
print(sorted(vysledky.items()))
[('v1', False), ('v2', False)]Fronta: bezpečné předávání práce
Nejlepší zámek je ten, který nemusíš psát. queue.Queue je fronta připravená pro vlákna a zamyká si sama. Jedna strana práci vkládá, druhá ji odebírá. Vlákna tak nesdílejí data, jen si je předávají. Konec se oznámí speciální hodnotou, kterou každý pracovník spotřebuje a skončí.
import queue
import threading
KONEC = object()
ulohy = queue.Queue(maxsize=2)
vysledky = []
def pracovnik():
while True:
uloha = ulohy.get()
if uloha is KONEC:
break
vysledky.append(uloha.upper())
v = threading.Thread(target=pracovnik)
v.start()
for slovo in ["kafe", "čaj", "voda", "džus"]:
ulohy.put(slovo)
ulohy.put(KONEC)
v.join()
print(vysledky)
['KAFE', 'ČAJ', 'VODA', 'DŽUS']
maxsize=2 je zpětný tlak: když je fronta plná, put počká. Rychlý producent tak nezaplní paměť úlohami, které pracovník nestíhá.
Program stahuje 500 stránek a většinu času čeká na odpověď serveru. Co je přiměřené?
Při čekání na síť vlákno GIL pustí a ostatní běží. Procesy by fungovaly taky, ale stojí víc paměti a času. Pro velmi mnoho spojení se hodí i asyncio.
GIL: jeden nůž
Global Interpreter Lock je zámek uvnitř CPythonu. Pythonní bytecode smí v jednom procesu v daném okamžiku vykonávat jen jedno vlákno. Chrání vnitřní struktury, hlavně počítadla referencí z lekce Paměť, garbage collector a bytecode.
Dá se to změřit. Spustíš čtyři počítající vlákna a porovnáš čas procesoru s časem na hodinách. Poměr říká, kolik jader program v průměru využil. I na osmijádrovém stroji nepřekročí zhruba jedničku.
import sys
import threading
import time
def pocitej(n):
while n:
n -= 1
vlakna = [threading.Thread(target=pocitej, args=(3_000_000,)) for _ in range(4)]
hodiny = time.perf_counter()
procesor = time.process_time()
for v in vlakna:
v.start()
for v in vlakna:
v.join()
hodiny = time.perf_counter() - hodiny
procesor = time.process_time() - procesor
print("využila nejvýš asi jedno jádro:", procesor / hodiny < 1.3)
print("interval přepínání:", sys.getswitchinterval())
využila nejvýš asi jedno jádro: True interval přepínání: 0.005
GIL neznamená, že vlákna jsou k ničemu, ani že kód je bezpečný. Vlákna se můžou přepnout mezi libovolnými dvěma instrukcemi, a tak zámky potřebuješ i s ním.
Procesy: skutečný paralelismus
Každý proces má vlastní interpret, vlastní GIL a vlastní paměť. Změna proměnné v potomkovi se rodiče netýká.
from multiprocessing import Process
citac = 0
def zvys():
global citac
citac += 1
print("v potomkovi:", citac, flush=True)
if __name__ == "__main__":
p = Process(target=zvys)
p.start()
p.join()
print("v rodiči:", citac)
v potomkovi: 1 v rodiči: 0
Rozhraní ProcessPoolExecutor je stejné jako u vláken, takže přechod bývá změna jednoho slova.
from concurrent.futures import ProcessPoolExecutor
import os
def je_prvocislo(n):
if n < 2:
return False
return all(n % d for d in range(2, int(n**0.5) + 1))
def cislo_procesu(_):
return os.getpid()
if __name__ == "__main__":
cisla = [2, 15, 97, 1_000_003, 1_000_005]
with ProcessPoolExecutor(max_workers=2) as pool:
print(list(pool.map(je_prvocislo, cisla)))
pidy = set(pool.map(cislo_procesu, range(4)))
print("běželo mimo hlavní proces:", os.getpid() not in pidy)
[True, False, True, True, False] běželo mimo hlavní proces: True
Tuhle ukázku si pusť a porovnej časy na svém stroji. Výsledek závisí na počtu jader, proto tu žádná čísla neslibujeme.
from concurrent.futures import ProcessPoolExecutor
import time
def pocitej(n):
soucet = 0
for i in range(n):
soucet += i * i
return soucet
if __name__ == "__main__":
prace = [3_000_000] * 4
t = time.perf_counter()
list(map(pocitej, prace))
print(f"postupně: {time.perf_counter() - t:.2f} s")
t = time.perf_counter()
with ProcessPoolExecutor() as pool:
list(pool.map(pocitej, prace))
print(f"procesy: {time.perf_counter() - t:.2f} s")
Data se mezi procesy posílají přes pickle: objekt se převede na bajty, přenese a na druhé straně složí. Má to dva důsledky. Přenos něco stojí, takže se nevyplácí posílat obří data kvůli malé práci. A co nejde zabalit, to neprojde. Typicky lambda a funkce definované uvnitř jiné funkce.
import math
import pickle
print(pickle.loads(pickle.dumps([1, "dva", 3.0])))
print(pickle.loads(pickle.dumps(math.sqrt))(16))
pickle.dumps(lambda x: x + 1)
[1, 'dva', 3.0] 4.0
Rozdělení práce
Procesům se práce posílá po dávkách. Napiš rozdel(prvky, n), která vrátí seznam n seznamů. Dohromady obsahují všechny prvky v původním pořadí a délky dávek se liší nejvýš o jedna, delší dávky jsou vepředu.
def rozdel(prvky, n):
return [prvky]
print(rozdel(list(range(7)), 3))
Kolik to vůbec může zrychlit
Paralelizovat jde jen část programu. Načtení dat, spojení výsledků a režie zůstanou. Strop popisuje Amdahlův zákon, kde p je podíl práce, který jde rozdělit, a n je počet jader.
zrychlení = 1 / ((1 - p) + p / n)Amdahlův zákon
Napiš zrychleni(p, n) podle vzorce. Potom do proměnné strop ulož největší možné zrychlení pro p = 0.9, když by jader bylo neomezeně. Ve vzorci tehdy člen p / n zmizí.
def zrychleni(p, n):
return n
strop = 0
print(round(zrychleni(0.9, 8), 2), round(strop, 2))
Co vybrat
| Situace | Nástroj |
|---|---|
| Desítky až stovky čekání na síť nebo disk | ThreadPoolExecutor |
| Tisíce souběžných spojení | asyncio |
| Výpočet v čistém Pythonu | ProcessPoolExecutor |
| Výpočet v NumPy a podobných knihovnách | často stačí vlákna nebo vestavěný paralelismus knihovny |
| Předávání práce mezi vlákny | queue.Queue |
| Sdílený stav, který nejde odstranit | threading.Lock |
Program v čistém Pythonu počítá hodiny na plné vytížení procesoru. Co ho zrychlí na vícejádrovém stroji?
GIL pouští k bytecodu jen jedno vlákno a asyncio běží v jediném. Procesy mají každý svůj interpret i GIL.
Proč pool.map(lambda x: x * 2, data) selže u ProcessPoolExecutor, ale u ThreadPoolExecutor ne?
Vlákna sdílejí paměť, takže funkci jen zavolají. Do jiného procesu se posílá odkaz na funkci podle modulu a jména, a lambda žádné použitelné jméno nemá.
Pod kapotou · jak GIL opravdu funguje
Vlákno čekající na GIL spí na podmínkové proměnné s limitem sys.getswitchinterval() (výchozí 5 ms). Po vypršení nastaví gil_drop_request a držitel ho pustí při nejbližší kontrole eval breakeru. Ta není po každé instrukci, ale na zpětných skocích, na začátku funkcí a u některých volání. Vedlejší efekt: od 3.10 už pocet += 1 v jednoduché smyčce v praxi skoro nikdy nepřijde o hodnotu, protože mezi BINARY_OP a STORE žádná kontrola není. Stačí ale property, __add__ v Pythonu nebo volání funkce a chyba je zpět. Zelený test tedy nedokazuje nic. Bezpečnost nesmí stát na tomhle detailu.
C rozšíření GIL uvolňují přes Py_BEGIN_ALLOW_THREADS: blokující I/O, time.sleep, zlib, hashlib u větších vstupů, většina výpočtů v NumPy. Proto vlákna u numerických knihoven často škálují. Naopak jedno CPU-bound vlákno vedle I/O vláken zhoršuje latenci, protože po každém probuzení čekají na GIL až celý interval (convoy effect).
list.append nebo dict[k] = v jsou díky GIL atomické pro vestavěné typy, jazyk to ale negarantuje jako obecné pravidlo: d[k] = v s vlastním __hash__ nebo __eq__ spustí Python kód. d[k] += 1 atomické není nikdy.
Budoucnost: PEP 684 dal ve 3.12 každému subinterpretu vlastní GIL, zatím jen přes C API. PEP 703 přinesl od 3.13 experimentální build bez GIL (python3.13t). Tam přestávají platit implicitní záruky, na které se starý kód spoléhal.
Pod kapotou · start procesů, pooly a produkční pasti
Metoda startu. Ve 3.12 je výchozí fork na Linuxu, spawn na Windows a macOS. Od 3.14 se na Linuxu přechází na forkserver. fork je rychlý, ale kopíruje stav zámků bez vláken, která je držela: pokud jiné vlákno zrovna drželo zámek v logging nebo v alokátoru knihovny, potomek uvázne. Python 3.12 proto vydá DeprecationWarning, když forkuješ vícevláknový proces. Volbu dělej explicitně: mp_context=multiprocessing.get_context("spawn").
Pooly. ThreadPoolExecutor má výchozí max_workers min(32, os.cpu_count() + 4). ProcessPoolExecutor je na Windows omezen na 61 pracovníků. map u procesů má chunksize=1, což u milionu malých úloh znamená milion přenosů, takže ho zvyš. Executor.map navíc načte celý vstup dopředu a nehodí se na nekonečné proudy. Spadne-li pracovník (OOM killer, segfault), všechny čekající futures dostanou BrokenProcessPool. max_tasks_per_child (3.11) recykluje pracovníky a tlumí úniky paměti.
Velká data. Místo pickle použij multiprocessing.shared_memory nebo numpy.memmap a posílej jen názvy a tvary. SharedMemory musíš zavřít v každém procesu a jednou odlinkovat.
Kontext. threading.local je pro každé vlákno zvlášť, ale v poolu vlákna přežívají mezi úlohami, takže v něm může zůstat stav z předchozího požadavku. contextvars se do nového vlákna samy nepřenesou, předej je přes contextvars.copy_context().run.
Démoni a konec. Démonické vlákno se při ukončení zastaví uprostřed práce, klidně během zápisu. Thread.join(timeout) nevyvolá chybu, po něm musíš zkontrolovat is_alive(). Vlákno zvenku zabít nejde, potřebuje threading.Event, který samo kontroluje. Queue.shutdown existuje až od 3.13, ve 3.12 zůstávají ukončovací hodnoty.
Vyzkoušej si: Vlákna, procesy a čekání
Zjednodušený model: porovnej úlohy, které počítají, s těmi, které čekají, při použití vláken, procesů a asyncio.