Python Academy · Lektion

Grunderna i multiprocessing

Använd flera CPU-kärnor

Lektion 3 av 413 steg

Grunderna i multiprocessing är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Varför multiprocessing?

GIL hindrar trådar från att köra Python-bytekod parallellt. Modulen multiprocessing kringgår detta genom att starta separata processer, var och en med sin egen tolk och GIL, så att CPU-bundet arbete verkligen körs på flera kärnor.

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

Starta en process

Process(target=func) följer samma API som trådning. Anropa start() för att starta processen och join() för att vänta.

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

Skyddet för main

På vissa plattformar importerar barnprocesser Ert skript. Utan ett if __name__ == '__main__':-skydd kan processer skapas rekursivt. Omslut alltid startkoden med detta skydd.

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

Skicka argument

Använd args för positionsargument och kwargs för nyckelordsargument, precis som med trådar. Argumenten serialiseras med pickle och skickas till barnprocessen.

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

En pool med arbetare

multiprocessing.Pool hanterar en grupp processer. pool.map delar upp ett itererbart objekt mellan dem och samlar resultaten i ordning.

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

API:t concurrent.futures erbjuder också ProcessPoolExecutor, med samma submit/map-gränssnitt som Ni såg för trådar.

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

Separata minnesutrymmen

Varje process har ett eget minne. Om en global variabel ändras i en barnprocess ändras inte förälderns kopia. Data måste returneras eller delas uttryckligen.

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

Hämta tillbaka resultat

Eftersom minnet inte delas bör resultat returneras via Pool.map, executor-objekt eller köer i stället för att globala variabler ändras.

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

apply_async för enstaka anrop

apply_async schemalägger ett anrop och returnerar ett resultatobjekt. Anropa .get() för att hämta värdet.

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

Krav på pickle-serialisering

Mål och argument måste vara picklable så att de kan passera processgränsen. Funktioner på toppnivå fungerar; lambdas och lokala funktioner gör det vanligtvis inte.

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

När processer är rätt val

Använd processer för CPU-bundet arbete: matematik, bildbehandling och tolkning. Kostnaden för att starta processer och serialisera med pickle gör dem lämpliga för färre, tyngre uppgifter snarare än många små.

import multiprocessing as mp

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

Snabbkontroll

Testa förståelsen av multiprocessing.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er grunderna i multiprocessing:

Processer kringgår GIL och möjliggör verklig CPU-parallellism.
Använd skyddet if __name__ == '__main__'.
Pool och ProcessPoolExecutor fördelar arbete och samlar resultat.
Minne delas inte; argument måste kunna serialiseras med pickle.

Nästa steg: dela data säkert med köer och lås.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grunderna i multiprocessing” gratis?

Ja – hela texten till ”Grunderna i multiprocessing” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grunderna i multiprocessing”?

Använd flera CPU-kärnor Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Grunderna i multiprocessing”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Python Academy