1. `Multiprocessing`: Questa è generalmente la scelta migliore per le attività legate alla CPU (compiti che trascorrono la maggior parte del loro tempo a fare calcoli). Crea più processi, ognuno con il proprio interprete, permettendo il vero parallelismo e bypassando il blocco dell'interprete globale (GIL) che limita il threading in cpython.
`` `Python
Import Multiprocessing
def processo_item (elemento):
"" "La funzione da eseguire in parallelo." ""
# Il tuo codice per elaborare un singolo elemento va qui.
risultato =elemento * 2 # Esempio:raddoppiare l'articolo
risultato di ritorno
Se __name__ =='__main__':# importante per la compatibilità di Windows
Articoli =intervallo (10)
con multiprocessing.pool (processi =multiprocessing.cpu_count ()) come pool:
Risultati =pool.map (process_item, articoli)
Stampa (risultati)
`` `
* `multiprocessing.pool` crea un pool di processi di lavoro.
* `pool.map` applica` processo_item` a ciascun elemento in `elementi` contemporaneamente. Restituisce un elenco dei risultati nello stesso ordine dell'input.
* `multiprocessing.cpu_count ()` determina il numero di core della CPU, consentendo un parallelismo ottimale. È possibile specificare un numero minore di processi se necessario.
2. `concurrent.futures`: Ciò fornisce un'interfaccia di livello superiore sia per i thread che per i processi, offrendo maggiore flessibilità. Per le attività legate alla CPU, ti consigliamo di utilizzare `ProcessPoolexecutor`.
`` `Python
Importazione Concurrent.Futures
def processo_item (elemento):
"" "La funzione da eseguire in parallelo." ""
# Il tuo codice per elaborare un singolo elemento va qui.
risultato =elemento * 2 # Esempio:raddoppiare l'articolo
restituisce elemento, risultato #return sia input che output su Track
Se __Name__ =='__main__':
Articoli =intervallo (10)
con concurrent.futures.processpoolexecutor () come esecutore:
Risultati =Executor.map (Process_item, articoli) #order preserved
Per l'articolo, risultati in risultati:
print (f "input:{item}, output:{risultato}")
`` `
`concurrent.Futures` offre un maggiore controllo, in particolare con` Executor.submit` per le singole attività e la gestione delle eccezioni.
3. `threading` (generalmente non consigliato per le attività legate alla CPU): Il threading è adatto per le attività legate all'I/O (attività che trascorrono la maggior parte del loro tempo ad aspettare risorse esterne come richieste di rete o operazioni su disco). A causa del GIL, i thread in Cpython non forniscono veri parallelismo per le attività legate alla CPU.
`` `Python
threading di importazione
def processo_item (elemento, risultati):
#Il tuo codice per elaborare un singolo elemento va qui.
risultato =elemento * 2 #example:raddoppiare l'elemento
Results.append (risultato)
Se __Name__ =='__main__':
Articoli =intervallo (10)
Risultati =[]
threads =[]
Per l'articolo negli articoli:
thread =threading.Thread (target =process_item, args =(elemento, risultati))
threads.append (thread)
thread.start ()
per thread in thread:
thread.Join ()
Stampa (risultati)
`` `
Questo esempio utilizza un elenco condiviso (`risultati`) che richiede un'attenta considerazione per la sicurezza del thread (usando i blocchi se necessario). È più complesso di `multiprocessing` o` concultent.futures` per carichi di lavoro legati alla CPU e probabilmente non fornirà un aumento delle prestazioni per loro.
Scegliere il metodo giusto:
* Legato alla CPU: Utilizzare `multiprocessing` o` concurrent.futures` con `ProcessPoolexecutor`. `Multiprocessing` è generalmente più semplice per le operazioni di stile mappa-reduce.
* I/O-legato: Usa `threading` o` concultent.futures` con `threadpoolexecutor`. `concurrent.Futures` offre una migliore gestione e controllo delle eccezioni.
* misto: Potrebbe essere necessario un approccio ibrido, combinando processi per parti e fili ad alta intensità di CPU per parti legate all'I/O.
Ricorda di gestire potenziali eccezioni all'interno delle funzioni del lavoratore e considerare il sovraccarico di creare e gestire processi o thread. Per compiti molto piccoli, le spese generali potrebbero superare i benefici della parallelizzazione. Profila il tuo codice per determinare se la parallelizzazione sta effettivamente fornendo un miglioramento delle prestazioni.
Programmazione © www.354353.com