Hoe u uw Python-code gelijktijdig kunt uitvoeren met behulp van threads

Uitvoeringstijd is een van de gebruikelijke maatstaven voor de efficiëntie van een programma. Hoe sneller de uitvoeringstijd, hoe beter het programma. Threading is een techniek waarmee een programma meerdere taken of processen tegelijk kan uitvoeren.

Je leert hoe je de ingebouwde Python gebruikt draadsnijden moduul en de gelijktijdige.functies moduul. Beide modules bieden eenvoudige manieren om threads te maken en te beheren

Belang van draadsnijden

Draadsnijden vermindert de hoeveelheid tijd die een programma nodig heeft om een ​​taak te voltooien. Als de taak meerdere onafhankelijke taken bevat, kunt u threading gebruiken om de taken gelijktijdig uit te voeren, waardoor de wachttijd van het programma voor het voltooien van de ene taak voordat u naar de volgende gaat, wordt verkort.

Bijvoorbeeld een programma dat meerdere afbeeldingsbestanden van internet downloadt. Dit programma kan threading gebruiken om de bestanden parallel te downloaden in plaats van één voor één. Dit elimineert de tijd die het programma zou moeten wachten tot het downloadproces van het ene bestand is voltooid voordat het naar het volgende bestand gaat.

Eerste programma vóór het inrijgen

De functie in het volgende programma vertegenwoordigt een taak. De taak is om de uitvoering van het programma een seconde te pauzeren. Het programma roept de functie twee keer aan en creëert zo twee taken. Vervolgens berekent het de tijd die nodig was om het hele programma uit te voeren en geeft het vervolgens weer op het scherm.

importeren tijd
start_time = tijd.perf_counter()
defpauze():
 afdrukken('1 seconde slapen...')
 tijd.slaap(1)
 afdrukken('Klaar met slapen...')
pauze()
pauze()
finish_time = tijd.perf_counter()
afdrukken(f'Klaar {ronde (finish_time - start_time, 2)} tweede (s)')

De uitvoer laat zien dat het programma 2,01 seconden nodig had om uit te voeren. Elke taak duurde een seconde en de rest van de code duurde 0,01 seconden om uit te voeren.

U kunt threading gebruiken om beide taken gelijktijdig uit te voeren. Dit duurt beide taken een seconde om uit te voeren.

Threading implementeren met behulp van de threading-module

Om de initiële code te wijzigen om threading te implementeren, importeert u het draadsnijden moduul. Maak twee threads, draad_1 En draad_2 de... gebruiken Draad klas. Bel de begin methode op elke thread om de uitvoering ervan te starten. Bel de meedoen methode op elke thread om te wachten tot de uitvoering ervan is voltooid voordat de rest van het programma wordt uitgevoerd.

importeren tijd
importeren draadsnijden
start_time = tijd.perf_counter()
defpauze():
 afdrukken('1 seconde slapen...')
 tijd.slaap(1)
 afdrukken('Klaar met slapen...')
draad_1 = draadsnijden. Discussie (doel=pauze)
draad_2 = draadsnijden. Discussie (doel=pauze)
thread_1.start()
draad_2.start()
thread_1.join()
thread_2.join()
finish_time = tijd.perf_counter()
afdrukken(f'Klaar {ronde (finish_time - start_time, 2)} tweede (s)')

Het programma zal beide threads gelijktijdig uitvoeren. Dit vermindert de hoeveelheid tijd die nodig is om beide taken uit te voeren.

De uitvoer laat zien dat de tijd die nodig is om dezelfde taken uit te voeren ongeveer een seconde is. Dit is de helft van de tijd die het oorspronkelijke programma in beslag nam.

Threading implementeren met de module concurrent.futures

Python 3.2 zag de introductie van de gelijktijdige.toekomsten moduul. Deze module biedt een interface op hoog niveau voor het uitvoeren van asynchrone taken met behulp van threads. Het biedt een eenvoudigere manier om taken parallel uit te voeren.

Om het initiële programma aan te passen om threading te gebruiken, importeert u de module concurrent.features. Gebruik de ThreadPoolExecutor class uit de module concurrent.futures om een ​​pool met threads te maken. Dien de pauze twee keer naar het zwembad. De indienen methode retourneert een toekomst object dat het resultaat van de functieaanroep vertegenwoordigt.

Herhaal over de toekomsten en print hun resultaten met behulp van de resultaat methode.

importeren tijd
importeren gelijktijdige.toekomsten
start_time = tijd.perf_counter()
defpauze():
 afdrukken('1 seconde slapen...')
 tijd.slaap(1)
opbrengst'Klaar met slapen...'
met gelijktijdige.toekomsten. ThreadPoolExecutor() als uitvoerder:
 resultaten = [executor.submit (pauze) voor _ in bereik(2)]
voor F in concurrent.futures.as_completed (resultaten):
 afdrukken (f.resultaat())
finish_time = tijd.perf_counter()
afdrukken(f'Klaar {ronde (finish_time - start_time, 2)} tweede (s)')

De module concurrent.features zorgt voor het starten en samenvoegen van de threads voor u. Dit maakt je code schoner.

De output is identiek aan die van de threading module. De threading-module is handig voor eenvoudige gevallen waarin u een paar threads parallel moet laten lopen. Aan de andere kant is de concurrent.futures-module handig voor complexere gevallen waarin u veel taken tegelijkertijd moet uitvoeren.

Threading gebruiken in een real-world scenario

Door threads te gebruiken om het bovenstaande programma uit te voeren, werd de tijd met een seconde verkort. In de echte wereld besparen threads meer tijd. Maak een programma dat afbeeldingen van internet downloadt. Start op creëren van een nieuwe virtuele omgeving. Voer de volgende opdracht uit in de terminal om het aanvragen bibliotheek:

pip installatieverzoeken

Met de verzoekenbibliotheek kunt u HTTP-verzoeken verzenden. Importeer de aanvraagbibliotheek en de tijdbibliotheek.

importeren aanvragen
importeren tijd

Maak een lijst met URL's van de afbeeldingen die u wilt downloaden. Laat het er minstens tien zijn, zodat u een aanzienlijk verschil kunt opmerken wanneer u threading implementeert.

img_urls = [
' https://images.unsplash.com/photo-1524429656589-6633a470097c',
' https://images.unsplash.com/photo-1530224264768-7ff8c1789d79',
' https://images.unsplash.com/photo-1564135624576-c5c88640f235',
' https://images.unsplash.com/photo-1541698444083-023c97d3f4b6',
' https://images.unsplash.com/photo-1522364723953-452d3431c267',
' https://images.unsplash.com/photo-1513938709626-033611b8cc03',
' https://images.unsplash.com/photo-1507143550189-fed454f93097',
' https://images.unsplash.com/photo-1493976040374-85c8e12f0c0e',
' https://images.unsplash.com/photo-1504198453319-5ce911bafcde',
' https://images.unsplash.com/photo-1530122037265-a5f1f91d3b99',
' https://images.unsplash.com/photo-1516972810927-80185027ca84',
' https://images.unsplash.com/photo-1550439062-609e1531270e',
]

Loop over de lijst van URL's die elke afbeelding downloaden naar dezelfde map die uw project bevat. Geef de tijd weer die nodig is om de afbeeldingen te downloaden door de eindtijd af te trekken van de starttijd.

start_time = tijd.perf_counter()
voor img_url in img_urls:
 img_bytes = aanvragen.get (img_url).inhoud
 img_name = img_url.split('/')[3]
 img_naam = F'{img_name}.jpg'
met openen (img_name, 'wb') als img_bestand:
 img_file.write (img_bytes)
 afdrukken(F'{img_name} is gedownload...')
finish_time = tijd.perf_counter()
afdrukken(f'Klaar {finish_time - start_time} seconden')

Het programma heeft ongeveer 22 seconden nodig om de 12 afbeeldingen te downloaden. Het kan voor jou verschillen, omdat de tijd die nodig is om de afbeeldingen te downloaden ook afhangt van de snelheid van je internet.

Wijzig het programma om threading te gebruiken met behulp van de module concurrent.features. Gebruik in plaats van een lus een functie. Dit is de functie die je doorgeeft aan de uitvoerder voorbeeld.

importeren aanvragen
importeren tijd
importeren gelijktijdige.toekomsten
img_urls = [
' https://images.unsplash.com/photo-1524429656589-6633a470097c',
' https://images.unsplash.com/photo-1530224264768-7ff8c1789d79',
' https://images.unsplash.com/photo-1564135624576-c5c88640f235',
' https://images.unsplash.com/photo-1541698444083-023c97d3f4b6',
' https://images.unsplash.com/photo-1522364723953-452d3431c267',
' https://images.unsplash.com/photo-1513938709626-033611b8cc03',
' https://images.unsplash.com/photo-1507143550189-fed454f93097',
' https://images.unsplash.com/photo-1493976040374-85c8e12f0c0e',
' https://images.unsplash.com/photo-1504198453319-5ce911bafcde',
' https://images.unsplash.com/photo-1530122037265-a5f1f91d3b99',
' https://images.unsplash.com/photo-1516972810927-80185027ca84',
' https://images.unsplash.com/photo-1550439062-609e1531270e',
]
start_time = tijd.perf_counter()
defdownload_afbeelding(img_url):
 img_bytes = aanvragen.get (img_url).inhoud
 img_name = img_url.split('/')[3]
 img_naam = F'{img_name}.jpg'
met openen (img_name, 'wb') als img_bestand:
 img_file.write (img_bytes)
 afdrukken(F'{img_name} is gedownload...')
met gelijktijdige.toekomsten. ThreadPoolExecutor() als uitvoerder:
 uitvoerder.map (download_image, img_urls)
finish_time = tijd.perf_counter()
afdrukken(f'Klaar {finish_time-start_time} seconden')

Na het introduceren van threading. De tijd vermindert aanzienlijk. Het duurde slechts 4 seconden om de uitvoering van het programma te voltooien.

Scenario's geschikt voor draadsnijden

Enkele van de scenario's die geschikt zijn voor threading zijn:

• I/O-gebonden taken: Als het programma het grootste deel van de tijd besteedt aan het wachten op invoer- of uitvoerbewerkingen om te voltooien. Threading kan de prestaties verbeteren doordat andere taken kunnen worden uitgevoerd terwijl wordt gewacht tot de I/O-bewerkingen zijn voltooid.
• web schrapen: Webscraping omvat het maken van HTTP-verzoeken en het parseren van HTML-antwoorden. Threading helpt het proces te versnellen doordat u meerdere verzoeken tegelijk kunt doen.
• CPU-gebonden taken: Threading kan helpen om de prestaties te verbeteren door meerdere taken parallel uit te voeren.

Maak uzelf vertrouwd met threading in andere talen

Python is niet de enige taal die threading ondersteunt. De meeste programmeertalen ondersteunen een vorm van threading. Het is belangrijk om vertrouwd te raken met de implementatie van threads in andere talen. Dit voorziet u van de nodige vaardigheden om verschillende scenario's aan te pakken waarbij threading van toepassing kan zijn.