Vitajte na [www.pocitac.win] Pripojiť k domovskej stránke Obľúbené stránky
1. „Multiprocessing“: Toto je všeobecne najlepšia voľba pre úlohy viazané na CPU (úlohy, ktoré trávia väčšinu času výpočtami). Vytvára viac procesov, každý s vlastným tlmočníkom, ktorý umožňuje skutočný paralelizmus a obíde zámok globálneho tlmočníka (GIL), ktorý obmedzuje závity v cpythone.
`` `Python
importovať multiprientovanie
def process_item (položka):
"" "Funkcia, ktorá sa má vykonať paralelne." "
# Váš kód na spracovanie jednej položky ide sem.
Výsledok =položka * 2 # Príklad:Zdvojnásobte položku
výsledok návratnosti
Ak __name__ =='__main__':# Dôležité pre kompatibilitu so systémom Windows
položky =rozsah (10)
s multiprocessing.pool (processes =multiprocessing.cpU_count ()) ako fondy:
Výsledky =Pool.map (Process_item, položky)
Tlač (výsledky)
`` `
* `multiprocessing.pool` vytvára skupinu pracovných procesov.
* `Pool.map` aplikuje` Process_item` na každú položku v `položky" súbežne. Vráti zoznam výsledkov v rovnakom poradí ako vstup.
* `multiprocessing.cpu_count ()` určuje počet jadier CPU, čo umožňuje optimálny paralelizmus. V prípade potreby môžete zadať menší počet procesov.
2. `concurrent.futures`: Toto poskytuje rozhranie na vyššej úrovni pre vlákna aj procesy, ktoré ponúka väčšiu flexibilitu. Pri úlohách viazaných na CPU budete chcieť použiť „ProcessPooLExecutor“.
`` `Python
import súbežné.
def process_item (položka):
"" "Funkcia, ktorá sa má vykonať paralelne." "
# Váš kód na spracovanie jednej položky ide sem.
Výsledok =položka * 2 # Príklad:Zdvojnásobte položku
Vrátená položka, výsledok #return tak vstup a výstup na sledovanie
Ak __name__ =='__main__':
položky =rozsah (10)
s Concurrent.futures.ProcesspooLExecutor () ako exekútor:
výsledky =executor.map (Process_item, položky) #ODER
Pre položku výsledok vo výsledkoch:
print (f "input:{item}, výstup:{result}")
`` `
`Concurrent.Futures 'ponúka väčšiu kontrolu, najmä s` executor.submit` pre jednotlivé úlohy a výnimky na riešenie.
3. `Vláknenie“ (zvyčajne sa neodporúča pre úlohy viazané na CPU): Vlákno je vhodné pre úlohy viazaných na I/O (úlohy, ktoré trávia väčšinu času čakaním na externé zdroje, ako sú požiadavky na sieť alebo diskové operácie). Z dôvodu GIL nevity v Cpython neposkytujú skutočný paralelizmus pre úlohy viazané na CPU.
`` `Python
importovaný závit
def process_item (položka, výsledky):
#Tvoj kód na spracovanie jednej položky tu ide.
result =item * 2 #example:Dvojnásobok položky
resuls.ppend (výsledok)
Ak __name__ =='__main__':
položky =rozsah (10)
Výsledky =[]
vlákna =[]
pre položky v položkách:
vlákno =závitové
vlákna.prend (vlákno)
vlákno.start ()
Pre vlákno v vláknach:
vlákno.join ()
Tlač (výsledky)
`` `
Tento príklad používa zdieľaný zoznam („výsledky“), ktorý si vyžaduje dôkladné zváženie bezpečnosti vlákna (v prípade potreby použitia zámkov). Je to zložitejšie ako „multiprocessing“ alebo `súbežné
Výber správnej metódy:
* CPU viazané: Použite `multiprocessing` alebo` concurrent.futures` s `processpooLExecutor". „Multiprocessing“ je vo všeobecnosti jednoduchší pre priame operácie štýlu mapy redukcie.
* i/o-viazané: Použite `Threading` alebo` Concurrent.futures` s `ThreadpooLExecutor`. `Concurrent.Futures 'ponúka lepšiu manipuláciu a kontrolu výnimky.
* zmiešané: Môže byť potrebný hybridný prístup, ktorý kombinuje procesy pre časti a vlákna náročné na procesor pre časti I/O viazané na časti.
Nezabudnite zvládnuť potenciálne výnimky vo funkciách vášho pracovníka a zvážte režijnú náklady na vytváranie a správu procesov alebo vlákien. Pre veľmi malé úlohy by režijné náklady mohli prevážiť výhody paralelizácie. Profilujte svoj kód tak, aby ste zistili, či paralelizácia skutočne poskytuje zlepšenie výkonu.