Ako vylepšiť svoj kód Python pomocou súbežnosti a paralelnosti

Kľúčové informácie

• Súbežnosť a paralelizmus sú základnými princípmi vykonávania úloh vo výpočtovej technike, pričom každá z nich má svoje odlišné vlastnosti.
• Súbežnosť umožňuje efektívne využitie zdrojov a lepšiu odozvu aplikácií, zatiaľ čo paralelizmus je rozhodujúci pre optimálny výkon a škálovateľnosť.
• Python poskytuje možnosti na spracovanie súbežnosti, ako je vytváranie vlákien a asynchrónne programovanie s asyncio, ako aj paralelizmus pomocou modulu multiprocessingu.

Súbežnosť a paralelizmus sú dve techniky, ktoré vám umožňujú spustiť niekoľko programov súčasne. Python má viacero možností na spracovanie úloh súčasne a paralelne, čo môže byť mätúce.

Preskúmajte dostupné nástroje a knižnice na správnu implementáciu súbežnosti a paralelizmu v Pythone a ako sa líšia.

Pochopenie súbežnosti a paralelnosti

Súbežnosť a paralelizmus sa týkajú dvoch základných princípov vykonávania úloh vo výpočtovej technike. Každý má svoje odlišné vlastnosti.

1. Súbeh je schopnosť programu riadiť viacero úloh súčasne bez toho, aby ich nutne vykonával v rovnakom čase. Točí sa okolo myšlienky prekladania úloh, prepínania medzi nimi spôsobom, ktorý vyzerá simultánne.
2. Paralelizmusna druhej strane zahŕňa vykonávanie viacerých úloh skutočne paralelne. Zvyčajne to využíva viac procesorových jadier alebo procesorov. Paralelizmus dosahuje skutočné simultánne vykonávanie, čo vám umožňuje vykonávať úlohy rýchlejšie a je vhodné pre výpočtovo náročné operácie.

Význam súbežnosti a paralelizmu

Potrebu súbežnosti a paralelizmu vo výpočtovej technike nemožno preceňovať. Tu je dôvod, prečo sú tieto techniky dôležité:

1. Využitie zdrojov: Súbežnosť umožňuje efektívne využitie systémových zdrojov, čím zabezpečuje, že úlohy aktívne napredujú, a nie nečinne čakať na externé zdroje.
2. Schopnosť reagovať: Súbežnosť môže zlepšiť odozvu aplikácií, najmä v scenároch zahŕňajúcich používateľské rozhrania alebo webové servery.
3. Výkon: Paralelnosť je rozhodujúca pre dosiahnutie optimálneho výkonu, najmä v úlohách spojených s CPU, ako sú zložité výpočty, spracovanie údajov a simulácie.
4. Škálovateľnosť: Súbežnosť aj paralelizmus sú nevyhnutné pre budovanie škálovateľných systémov.
5. Odolnosť voči budúcnosti: Keďže hardvérové ​​trendy naďalej uprednostňujú viacjadrové procesory, schopnosť využívať paralelizmus bude čoraz nevyhnutnejšia.

Súbežnosť v Pythone

Súbežnosť v Pythone môžete dosiahnuť pomocou vlákien a asynchrónneho programovania s knižnicou asyncio.

Threading v Pythone

Threading je mechanizmus súbežnosti Pythonu, ktorý vám umožňuje vytvárať a spravovať úlohy v rámci jedného procesu. Vlákna sú vhodné pre určité typy úloh, najmä tie, ktoré sú viazané na I/O a môžu mať prospech zo súbežného vykonávania.

Pythonov závitovanie modul poskytuje rozhranie na vysokej úrovni na vytváranie a správu vlákien. Zatiaľ čo GIL (Global Interpreter Lock) obmedzuje vlákna z hľadiska skutočného paralelizmu, stále môžu dosiahnuť súbežnosť efektívnym prekladaním úloh.

Nižšie uvedený kód ukazuje príklad implementácie súbežnosti pomocou vlákien. Používa knižnicu požiadaviek Pythonu na odoslanie požiadavky HTTP, čo je bežná úloha blokovania I/O. Používa tiež časový modul na výpočet času vykonania.

import requests
import time
import threading
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# function to request a URL
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")
# Execute without threads and measure execution time
start_time = time.time()
for url in urls:
 download_url(url)
end_time = time.time()
print(f"Sequential download took {end_time - start_time:.2f} seconds\n")
# Execute with threads, resetting the time to measure new execution time
start_time = time.time()
threads = []
for url in urls:
 thread = threading.Thread(target=download_url, args=(url,))
 thread.start()
 threads.append(thread)
# Wait for all threads to complete
for thread in threads:
 thread.join()
end_time = time.time()
print(f"Threaded download took {end_time - start_time:.2f} seconds")

Spustením tohto programu by ste mali vidieť, o koľko rýchlejšie sú požiadavky s vláknami ako sekvenčné požiadavky. Aj keď je rozdiel len zlomok sekundy, pri použití vlákien pre úlohy viazané na I/O získate jasnú predstavu o zlepšení výkonu.

Asynchrónne programovanie s Asyncio

asyncio poskytuje slučku udalostí, ktorá riadi asynchrónne úlohy nazývané korutíny. Coroutines sú funkcie, ktoré môžete pozastaviť a obnoviť, vďaka čomu sú ideálne pre úlohy spojené s I/O. Knižnica je užitočná najmä pre scenáre, kde úlohy zahŕňajú čakanie na externé zdroje, ako sú sieťové požiadavky.

Môžete upraviť predchádzajúci príklad odoslania požiadavky, aby ste s ním mohli pracovať asyncio:

import asyncio
import aiohttp
import time
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# asynchronous function to request URL
asyncdefdownload_url(url):
asyncwith aiohttp.ClientSession() as session:
asyncwith session.get(url) as response:
 content = await response.text()
 print(f"Downloaded {url} - Status Code: {response.status}")
# Main asynchronous function
asyncdefmain():
# Create a list of tasks to download each URL concurrently
 tasks = [download_url(url) for url in urls]
# Gather and execute the tasks concurrently
await asyncio.gather(*tasks)
start_time = time.time()
# Run the main asynchronous function
asyncio.run(main())
end_time = time.time()
print(f"Asyncio download took {end_time - start_time:.2f} seconds")

Pomocou kódu môžete sťahovať webové stránky súčasne pomocou asyncio a využívať výhody asynchrónnych I/O operácií. Pri úlohách viazaných na I/O to môže byť efektívnejšie ako vytváranie vlákien.

Paralelnosť v Pythone

Paralelizmus môžete implementovať pomocou Pythonov multiprocessing modul, ktorý vám umožní naplno využiť výhody viacjadrových procesorov.

Multiprocessing v Pythone

Pythonov multiprocessing modul poskytuje spôsob, ako dosiahnuť paralelizmus vytvorením samostatných procesov, z ktorých každý má svoj vlastný interpret Python a pamäťový priestor. Toto efektívne obchádza Global Interpreter Lock (GIL), vďaka čomu je vhodný pre úlohy viazané na CPU.

import requests
import multiprocessing
import time
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# function to request a URL
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")
defmain():
# Create a multiprocessing pool with a specified number of processes
 num_processes = len(urls)
 pool = multiprocessing.Pool(processes=num_processes)
 start_time = time.time()
 pool.map(download_url, urls)
 end_time = time.time()
# Close the pool and wait for all processes to finish
 pool.close()
 pool.join()
 print(f"Multiprocessing download took {end_time-start_time:.2f} seconds")
main()

V tomto príklade multiprocessing spúšťa viacero procesov, čo umožňuje download_url funkcia bežať paralelne.

Kedy použiť súbežnosť alebo paralelnosť

Voľba medzi súbežnosťou a paralelizmom závisí od povahy vašich úloh a dostupných hardvérových prostriedkov.

Súbežnosť môžete použiť pri riešení úloh viazaných na I/O, ako napr čítanie a zápis do súborov alebo pri vytváraní sieťových požiadaviek a pri problémoch s pamäťovými obmedzeniami.

Multiprocessing použite, keď máte úlohy viazané na CPU, ktoré môžu ťažiť zo skutočného paralelizmu, a keď máte robustnú izoláciu medzi úlohami, kde by zlyhanie jednej úlohy nemalo ovplyvniť ostatné.

Využite súbežnosť a paralelnosť

Paralelnosť a súbežnosť sú efektívne spôsoby, ako zlepšiť odozvu a výkon vášho kódu Python. Je dôležité pochopiť rozdiely medzi týmito pojmami a vybrať si najefektívnejšiu stratégiu.

Python ponúka nástroje a moduly, ktoré potrebujete na zefektívnenie vášho kódu prostredníctvom súbežnosti alebo paralelizmu, bez ohľadu na to, či pracujete s procesmi viazanými na CPU alebo I/O.