(Tutorial) Definitive Guide: Threading in Python

Als u net begonnen bent in Python en u wilt meer weten, neem dan de DataCamp ‘ s Introduction to Data Science in Python cursus.

Inleiding

met Threading kunt u verschillende delen van uw proces gelijktijdig laten draaien (bron: RealPython). Deze verschillende onderdelen zijn meestal individueel en hebben een aparte eenheid van uitvoering die tot hetzelfde proces behoren., Het proces is niets anders dan een lopend programma dat individuele eenheden heeft die gelijktijdig kunnen worden uitgevoerd. Een webbrowser kan bijvoorbeeld een proces zijn, een applicatie die meerdere camera ‘ s tegelijk draait, kan een proces zijn; een videospel is een ander voorbeeld van een proces.

in een proces komt het concept van meerdere threading of algemeen bekend als multi-threading, waarbij meerdere threads samenwerken om een gemeenschappelijk doel te bereiken. Het meest cruciale voordeel van het gebruik van threads is dat u het programma parallel kunt uitvoeren.,

laten we het concept van threading begrijpen met behulp van een voorbeeld. Stel je voor dat je een applicatie hebt die het aantal auto ‘ s telt die de parkeerplaats van het winkelcentrum binnenkomen en verlaten. Uw apparaat heeft verschillende camera ‘ s die de in-en uitgang bewaken die aansluiten op een centraal apparaat. Elke camera heeft een algoritme om de stroom van auto ‘ s te controleren, die tot hetzelfde proces of programma behoren. Echter, elke camera, samen met het algoritme waarop het wordt uitgevoerd, kan deel uitmaken van een aparte thread., Niet alleen dat, maar zelfs de frames die worden gelezen van de camera en het algoritme dat voorspelt op de frames kunnen ook twee aparte threads zijn.

een ander voorbeeld kan een videospel zijn waarin het proces de taken parallel moet uitvoeren, zoals de graphics, gebruikersinteractie en netwerken (tijdens het spelen van multiplayer-spellen) omdat het te allen tijde responsief moet zijn. En om dit te bereiken, moet het gebruik maken van het concept van multi-threading, waarbij elke draad verantwoordelijk zou zijn voor het uitvoeren van elke onafhankelijke en individuele taak.,

een thread heeft zijn uitvoerstroom, wat betekent dat het proces meerdere dingen tegelijk zal hebben.

Het is belangrijk op te merken dat elk proces ten minste één thread heeft, en dat wordt main threadgenoemd. Als je programma geen gedefinieerde thread heeft, dan zal het tenminste de hoofd thread hebben, dat wil zeggen het proces zelf.

als je naar het bovenstaande diagram kijkt, is er een proces dat bestaat uit de hoofdthread die bestaat uit globale variabelen en drie verschillende threads t1, t2 en t3. Elke thread heeft zijn lokale variabelen en stroom van uitvoering van code., De threads delen over het algemeen de bronnen van het proces, zoals de bronnen die beschikbaar zijn voor de hoofdthread zullen ook worden gedeeld tussen de drie threads t1, t2 en t3. Alle threads hebben toegang tot de globale variabelen terwijl ze hun eigen lokale variabelen hebben.,

Er zijn verschillende soorten threads:

Kernel thread
User thread
combinatie van kernel en user thread

laten we nu eens kijken naar enkele van de voordelen van het hebben van threading in uw programma:

Multi-threading maakt het programma om de uitvoering te versnellen op voorwaarde dat het meerdere CPU ‘ s heeft.
hiermee kunt u ook andere taken uitvoeren terwijl de I/O-bewerkingen worden uitgevoerd met behulp van meerdere threads of zelfs hoofd thread samen met een enkele thread., Bijvoorbeeld, de snelheid waarmee de frames van de camera worden gelezen en afgeleid door het algoritme zal worden behandeld door verschillende threads. Vandaar dat het algoritme niet hoeft te wachten tot het frame wordt ingevoerd, en het frame-leesgedeelte niet hoeft te wachten tot het algoritme is uitgevoerd om het volgende frame te kunnen lezen.

Threads binnen hetzelfde proces kunnen het geheugen en de bronnen van de hoofd thread delen.,

Challenges of Threading:

onthoud dat Python werkt op basis van de CPython-implementatie, waardoor slechts één thread tegelijk kan worden uitgevoerd; threading kan niet alle taken versnellen. En de essentiële reden hiervoor is Global Interpreter Lock (GIL).

als je meer wilt weten over GIL, bekijk dan deze tutorial.
Als u op zoek bent naar het versnellen van de CPU-intensieve taak, dan is threading misschien niet de beste oplossing voor u. In dergelijke gevallen wordt multi-processing als nuttig beschouwd.,
om een programma uit te voeren dat bestaat uit verschillende threads, moet het snel overschakelen tussen threads; daarom moet het plannen worden afgehandeld in programma ‘ s waar je veel threads hebt.
het delen van bronnen kan ook een probleem zijn omdat alle threads dezelfde bronnen en geheugen van de globale variabelen delen. Daarom kunnen operaties uitgevoerd in een thread een geheugenfout veroorzaken voor een andere thread, of de andere thread kan het geheugen niet krijgen om zijn taak uit te voeren.,

Threading in Python

In Python is de threading-module een ingebouwde module die bekend staat als threading en kan direct worden geïmporteerd.
omdat bijna alles in Python wordt weergegeven als een object, is threading ook een object in Python. Een thread kan
- gegevens bevatten,
- opgeslagen in datastructuren zoals woordenboeken, lijsten, sets, enz.
- kan als parameter aan een functie worden doorgegeven.
een thread kan ook als proces worden uitgevoerd.,
een thread in Python kan verschillende toestanden hebben zoals:
- wacht,
- vergrendeld.

laten we nu leren hoe je threading in Python kunt implementeren.

Thread module in Python3

merk op dat Python3 achterwaarts compatibel is met de thread module, die bestaat in Python2.7. In Python3 kan het geïmporteerd worden als _thread module. Laten we een voorbeeld nemen en de module _thread begrijpen.,

import _thread #thread module importedimport time #time module

laten we een functie definiëren genaamd thread_delay, die twee parameters als invoer neemt, d.w.z. de naam van de thread en de vertraging. Binnen deze functie, zal je:

Definieer een teller met nul,
dan zul je rond te lopen met een while lus die drie keer zal draaien,
binnen de while lus, je zal time.sleep() om vertraging toe te voegen, deze vertraging zal nuttig zijn om de uitvoering van de thread te begrijpen., Deze vertraging zal in seconden zijn,
dan zult u uw teller verhogen met 1,
om te zien of uw thread-uitvoering soepel verloopt, zult u de naam van de thread en het tijdstip waarop de thread wordt uitgevoerd afdrukken.

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

om de threadfunctionaliteit toe te voegen aan de bovenstaande functie of om de bovenstaande functie in de thread uit te voeren, gebruikt u de start_new_thread methode, die zich in de _thread modulebevindt.

laten we de docstring van de start_new_thread methode bekijken.,

?_thread.start_new_thread

laten we in de functie doorgaan thread_delay zonder haakjes en de twee argumenten, d.w.z. threadnaam en de vertraging (om de draad uitvoering visualiseren omdat het zeer snel).

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 3))

uit de bovenstaande uitvoer kunt u zien dat de thread t1 als eerste wordt uitgevoerd., Ondertussen wacht thread t2 omdat er een vertraging van 3 seconden is, en zodra die vertraging is voltooid, wordt thread t2 uitgevoerd, en ook is de vertraging voor thread t1 slechts 1 seconde.

laten we nu de vertraging van t2 wijzigen naar 5 seconden, wat t2 zou starten na t1 zou zijn voltooid omdat t1 slechts 3 seconden nodig heeft om de uitvoering te voltooien.,

_thread.start_new_thread(thread_delay, ('t1', 1))_thread.start_new_thread(thread_delay, ('t2', 5))

Implementing threading using the Threading module

laten we hetzelfde voorbeeld gebruiken als hierboven, maar deze keer zal u de threading module gebruiken in plaats van de _thread module.

import threadingimport time

def thread_delay(thread_name, delay): count = 0 while count < 3: time.sleep(delay) count += 1 print(thread_name, '-------->', time.time())

binnen de threading module is een Thread klasse, die vergelijkbaar is met de start_new_thread functie van de _thread module.,

laten we eens kijken naar de docstring van Thread klasse, die verschillende parameters bevat zoals Groep, doel (zoals een functie), args, etc.

?threading.Thread

In de Thread class constructor zult u de doelfunctie passeren thread_delay en de argumenten van die functie.,

t1 = threading.Thread(target=thread_delay, args=('t1', 1))t2 = threading.Thread(target=thread_delay, args=('t2', 3))

In de threading module, om de thread uit te voeren, maakt u gebruik van de start() methode, die gewoon verantwoordelijk is voor het uitvoeren van de thread.

?t1.start

t1.start()t2.start()

u zult ook de join methode, wat betekent dat wacht tot alle thread uitvoering is voltooid., Dus welke code je ook geschreven hebt na dejoin methode zal alleen uitgevoerd worden als deze threads beëindigd zijn.

?t1.join

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

laten we nu het volume van kubus en vierkant berekenen met behulp van het threading-concept, wat mooi is recht door zee.

def volume_cube(a): print ("Volume of Cube:", a*a*a)

def volume_square(a): print ("Volume of Square:", a*a)

t1 = threading.Thread(target=volume_cube, args=(2))t2 = threading.Thread(target=volume_square, args=(3))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Wait; what? Zodra u de start methode uitgevoerd, het resulteerde in een fout., Dat komt omdat deargs parameter een tupel verwacht, en omdat devolume_cube envolume_square slechts één parameter verwacht, moet u daarom een komma in deargs parameter plaatsen na het specificeren van het eerste argument van de functies.

t1 = threading.Thread(target=volume_cube, args=(2,))t2 = threading.Thread(target=volume_square, args=(3,))

t1.start()t2.start()t1.join()t2.join()print("Thread execution is complete!")

Volume of Cube: 8Volume of Square: 9Thread execution is complete!

laten we nu leren threading als subklasse te gebruiken.,

Threading als subklasse

in deze sectie leert u hoe u een subklasse maakt van de thread-klasse, die beschikbaar is in de threadmodule, en dan thread-instanties maakt t1 en t2 uit die klasse.

u zou hier ook dezelfde thread_delay functie gebruiken.

laten we nu stap voor stap de bovenstaande code begrijpen:

u definieerde een klasse als DataCampThread, en in het class argument, u passeerde in de threading.Thread klasse., De reden dat je dat doet is dat je een subklasse wilt maken van de threading module. Door dit te doen kunt u alle methoden gebruiken die beschikbaar zijn in de threading.Thread klasse vergelijkbaar met het concept van overerving.
vervolgens definieerde u de init-methode van de klasse DataCampThread en gaf u de functie mee met de vertraging. De init is een constructor die vergelijkbaar is met de parameters die je hebt doorgegeven aan de threading.Thread Klasse, hier zou je doorgeven aan de DataCampThread klasse.,
dan initialiseer je de init methode van de belangrijkste threading.Thread klasse en dan gelijk naam en vertraging.
vervolgens definieert u de run methode, bedenk hier dat u de start methode hebt gedefinieerd, die in principe onder de motorkap de run methode aanroept. Omdat u de Hoofdklasse hebt geërfd, mag u wijzigingen aanbrengen in de run methode., Daarom, wanneer u de start methode aanroept, zullen alle wijzigingen die u aanbrengt in de run methode nu worden weergegeven.

conclusie

gefeliciteerd met het afronden van de tutorial.

Deze tutorial was een basis introductie tot threading in python. Threading is echter een zeer uitgebreid en essentieel onderwerp, en sommige concepten zijn misschien nog niet onderzocht. Voel je vrij om te kijken naar meer threading methoden zoals actieve aantal, huidige thread, enz.

als je meer wilt weten, bekijk dan ook Python ‘ s Thread-gebaseerde parallellisme.,

Als u net begonnen bent met Python en u wilt meer weten, neem dan de DataCamp ‘ s Introduction to Data Science in Python cursus.