0 dní v řadě · 0 bodů

Python pod kapotou · 35 min

Vlákna, procesy a GIL

Kdy pomůžou vlákna a kdy procesy, co je GIL, proč vzniká souběhová chyba a jak ji zamknout.

Hloubka
Úkoly
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.
text
ú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      ano

Dvě 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)
Výstup
[('a.txt', 5), ('bb.txt', 6), ('ccc.txt', 7)]
rychleji než postupně (0.6 s): True

Tř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)
Výstup
[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))
Výstup
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)
Výstup
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)
Výstup
200000
Úkol

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))
Výstup

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()))
Výstup
[('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)
Výstup
['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á.

Kvíz

Program stahuje 500 stránek a většinu času čeká na odpověď serveru. Co je přiměřené?

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())
Výstup
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ýstup
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)
Výstup
[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")
Výstup

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)
Výstup
[1, 'dva', 3.0]
4.0
Úkol

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))
Výstup

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.

text
zrychlení = 1 / ((1 - p) + p / n)
Úkol

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))
Výstup

Co vybrat

SituaceNástroj
Desítky až stovky čekání na síť nebo diskThreadPoolExecutor
Tisíce souběžných spojeníasyncio
Výpočet v čistém PythonuProcessPoolExecutor
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áknyqueue.Queue
Sdílený stav, který nejde odstranitthreading.Lock
Kvíz

Program v čistém Pythonu počítá hodiny na plné vytížení procesoru. Co ho zrychlí na vícejádrovém stroji?

Kvíz

Proč pool.map(lambda x: x * 2, data) selže u ProcessPoolExecutor, ale u ThreadPoolExecutor ne?

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.