Python Academy · Lezione

Nozioni di base su multiprocessing

Usare più core della CPU

Nozioni di base su multiprocessing è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Perché multiprocessing?

Il GIL impedisce ai thread di eseguire bytecode Python in parallelo. Il modulo multiprocessing aggira questo limite avviando processi separati, ciascuno con il proprio interprete e GIL, così le attività vincolate alla CPU vengono realmente eseguite su più core.

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

Avviare un processo

Process(target=func) rispecchia l'API del threading. Chiami start() per avviare il processo e join() per attenderne la conclusione.

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')

La protezione main

Su alcune piattaforme, i processi figli importano lo script. Senza una protezione if __name__ == '__main__': si possono creare processi ricorsivamente. Racchiuda sempre il codice di avvio al suo interno.

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()

Passaggio degli argomenti

Usi args per gli argomenti posizionali e kwargs per quelli con nome, proprio come con i thread. Gli argomenti vengono serializzati con pickle e inviati al processo figlio.

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()

Un pool di worker

multiprocessing.Pool gestisce un gruppo di processi. pool.map distribuisce un iterabile tra questi processi e raccoglie i risultati nell'ordine originale.

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

L'API concurrent.futures offre anche ProcessPoolExecutor, con la stessa interfaccia submit/map già vista per i thread.

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))))

Spazi di memoria separati

Ogni processo dispone della propria memoria. Modificare una variabile globale in un processo figlio non modifica la copia del processo padre. I dati devono essere restituiti o condivisi esplicitamente.

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)

Recuperare i risultati

Poiché la memoria non è condivisa, restituisca i risultati tramite Pool.map, gli executor o le code, invece di modificare variabili globali.

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 per chiamate singole

apply_async pianifica una singola chiamata e restituisce un riferimento al risultato. Chiami .get() per recuperare il valore.

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())

Requisito della serializzazione con pickle

Gli obiettivi e gli argomenti devono essere serializzabili con pickle per poter attraversare il confine tra processi. Le funzioni definite al livello principale funzionano; le lambda e le funzioni locali, in genere, no.

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]))

Quando scegliere i processi

Usi i processi per le attività vincolate alla CPU: calcoli matematici, elaborazione delle immagini e analisi. Il costo di avvio e serializzazione con pickle fa sì che siano più adatti a un numero ridotto di attività pesanti, anziché a molte attività brevi.

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]))

Verifica rapida

Verifichi la Sua comprensione di multiprocessing.

Ripasso

Ha appreso le basi di multiprocessing:

I processi aggirano il GIL per ottenere un vero parallelismo della CPU.
Usi la protezione if __name__ == '__main__'.
Pool e ProcessPoolExecutor distribuiscono il lavoro e raccolgono i risultati.
La memoria non è condivisa; gli argomenti devono essere serializzabili con pickle.

Avanti: condividere i dati in modo sicuro con code e lock.

Domande Frequenti

La lezione «Nozioni di base su multiprocessing» è gratuita?

Sì — il testo completo di «Nozioni di base su multiprocessing» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Nozioni di base su multiprocessing»?

Usare più core della CPU Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Nozioni di base su multiprocessing»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy