Definitieve gids: Threading in Python-tutorial

Ben je net begonnen met Python en wil je meer leren? Volg dan de cursus Introduction to Data Science in Python van DataCamp.

Introductie

Met threading kun je verschillende delen van je proces gelijktijdig laten draaien (Bron: RealPython). Deze verschillende delen zijn doorgaans zelfstandig en hebben een aparte uitvoeringseenheid binnen hetzelfde proces. Een proces is niets anders dan een draaiend programma met afzonderlijke eenheden die parallel kunnen draaien. Een webbrowser kan bijvoorbeeld een proces zijn, een applicatie die meerdere camera’s tegelijk laat draaien kan een proces zijn; een videogame is een ander voorbeeld van een proces.

Binnen een proces komt het concept van meerdere threads, oftewel multithreading, waarbij meerdere threads samenwerken om een gemeenschappelijk doel te bereiken. Het belangrijkste voordeel van threads is dat je het programma parallel kunt laten draaien.

Laten we het concept van threading begrijpen met een voorbeeld. Stel, je hebt een applicatie die het aantal auto’s telt dat het parkeerterrein van een winkelcentrum in- en uitrijdt. Je apparatuur heeft verschillende camera’s die de in- en uitgang monitoren en verbonden zijn met een centraal apparaat. Elke camera heeft een algoritme om de stroom auto’s te volgen, en hoort bij hetzelfde proces of programma. Maar elke camera, samen met het algoritme waarop hij draait, kan deel uitmaken van een aparte thread. Sterker nog: de frames die van de camera worden gelezen en het algoritme dat voorspellingen doet op die frames, kunnen ook twee afzonderlijke threads zijn.

Een ander voorbeeld is een videogame, waarin het proces taken parallel moet uitvoeren, zoals graphics, gebruikersinteractie en netwerken (bij multiplayer), omdat de game altijd responsief moet zijn. Om dit te bereiken, moet het gebruikmaken van het concept van multithreading, waarbij elke thread verantwoordelijk is voor een zelfstandige taak.

Een thread heeft zijn eigen uitvoeringsstroom, wat betekent dat er binnen het proces meerdere dingen tegelijk gebeuren.

Belangrijk om te onthouden: elk proces heeft minstens één thread, de main thread. Als je programma geen extra thread definieert, is er in elk geval de main thread, oftewel het proces zelf.

Als je naar het bovenstaande diagram kijkt, zie je een proces met de main thread met globale variabelen en drie verschillende threads t1, t2 en t3. Elke thread heeft zijn eigen lokale variabelen en uitvoeringsstroom. Threads delen over het algemeen de resources van het proces; de resources die beschikbaar zijn voor de main thread worden dus ook gedeeld met de drie threads t1, t2 en t3. Alle threads hebben toegang tot de globale variabelen en hebben daarnaast hun eigen lokale variabelen.

Er zijn verschillende soorten threads:

• Kernelthread
• User thread
• Combinatie van kernel- en user thread

Laten we nu kijken naar enkele voordelen van threading in je programma:

• Multithreading kan de uitvoering van het programma versnellen, mits er meerdere CPU’s beschikbaar zijn.

• Het stelt je ook in staat andere taken uit te voeren terwijl I/O-bewerkingen plaatsvinden, met behulp van meerdere threads of zelfs de main thread samen met één extra thread. Bijvoorbeeld: de snelheid waarmee frames van de camera worden gelezen en door het algoritme worden geïnterpreteerd, wordt door verschillende threads afgehandeld. Daardoor hoeft het algoritme niet te wachten op een nieuw frame, en hoeft het inlezen van frames niet te wachten tot het algoritme klaar is om het volgende frame te lezen.

• Threads binnen hetzelfde proces kunnen het geheugen en de resources van de main thread delen.

Uitdagingen van threading

• Onthoud dat Python gebaseerd is op de CPython-implementatie, die beperkt dat er maar één thread tegelijk actief is; threading versnelt dus niet alle taken. De belangrijkste reden hiervoor is de Global Interpreter Lock (GIL).

  Wil je meer leren over de GIL? Bekijk dan deze tutorial.

• Als je CPU-intensieve taken wilt versnellen, is threading mogelijk niet de beste oplossing. In zulke gevallen is multiprocessing vaak geschikter.

• Om een programma met verschillende threads uit te voeren, moet er snel tussen threads gewisseld worden; daarom is scheduling belangrijk in programma’s met veel threads.

• Resource sharing kan ook problematisch zijn, omdat alle threads dezelfde resources en het geheugen van globale variabelen delen. Daardoor kan een bewerking in de ene thread een geheugenfout veroorzaken in een andere thread, of krijgt die andere thread mogelijk niet genoeg geheugen om zijn taak uit te voeren.

Threading in Python

• In Python is de threadingmodule een ingebouwde module met de naam threading die je direct kunt importeren.

• Omdat bijna alles in Python als object wordt weergegeven, is een thread ook een object in Python. Een thread kan

  • Gegevens vasthouden,
  • Worden opgeslagen in datastructuren zoals dictionaries, lists, sets, enz.,
  • Als parameter aan een functie worden doorgegeven.
    
    

• Een thread kan ook als een proces worden uitgevoerd.

• Een thread in Python kan verschillende toestanden hebben, zoals:

  • Wachten,
  • Vergrendeld.

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

Thread-module in Python3

Let op: Python3 is backward compatible met de thread-module uit Python 2.7. In Python3 kun je deze importeren als de module _thread. Laten we een voorbeeld nemen en de _thread-module begrijpen.

import _thread #thread module imported
import time #time module

Definieer een functie met de naam thread_delay, die twee parameters als input neemt: de naam van de thread en de vertraging. In deze functie ga je:

• Een teller op nul zetten,
• Vervolgens een while-lus drie keer laten lopen,
• In de while-lus time.sleep() gebruiken om vertraging toe te voegen; deze vertraging helpt om de uitvoering van de thread te begrijpen. De vertraging is in seconden,
• Dan verhoog je je teller met 1,
• Om te zien of de uitvoering van je thread goed verloopt, print je de naam van de thread en het tijdstip waarop de thread wordt uitgevoerd.

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

Om de threadfunctionaliteit op de bovenstaande functie toe te passen, of om de functie in een thread te draaien, gebruik je de methode start_new_thread, die zich in de _thread-module bevindt.

Laten we de docstring van de methode start_new_thread bekijken.

?_thread.start_new_thread

Geef de functie thread_delay zonder haakjes door en de twee argumenten, namelijk de threadnaam en de vertraging (om de uitvoering van de thread te kunnen visualiseren, omdat die erg snel is).

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

10916



t1 --------> 1588077856.4221454
t1 --------> 1588077857.4418247
t2 --------> 1588077858.422453
t1 --------> 1588077858.4431
t2 --------> 1588077861.4371448
t2 --------> 1588077864.438915

Uit de bovenstaande output zie je dat thread t1 als eerste begint uit te voeren. Ondertussen wacht thread t2 vanwege een vertraging van 3 seconden, en zodra die vertraging voorbij is, wordt thread t2 uitgevoerd. Voor t1 is de vertraging slechts 1 seconde.

Laat we nu de vertraging van t2 wijzigen naar 5 seconden. Dan start t2 pas nadat t1 klaar is met uitvoeren, aangezien t1 slechts 3 seconden nodig heeft om te voltooien.

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

14632



t1 --------> 1588078001.4087512
t1 --------> 1588078002.4272866
t1 --------> 1588078003.432218
t2 --------> 1588078005.4082909
t2 --------> 1588078010.4268317
t2 --------> 1588078015.4283602

Threading implementeren met de threadingmodule

We gebruiken hetzelfde voorbeeld als hierboven, maar dit keer gebruik je de module threading in plaats van de module _thread.

import threading
import time

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

In de module threading zit een klasse Thread, vergelijkbaar met de functie start_new_thread uit de module _thread.

Bekijk de docstring van de klasse Thread, die verschillende parameters accepteert zoals group, target (bijv. een functie), args, enz.

?threading.Thread

In de constructor van de Thread-klasse geef je de doelfunctie thread_delay en de argumenten van die functie door.

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

In de threadingmodule gebruik je de methode start() om de thread te starten of uit te voeren; die is simpelweg verantwoordelijk voor het draaien van de thread.

?t1.start

t1.start()
t2.start()

t1 --------> 1588081121.7790291
t1 --------> 1588081122.7962046
t2 --------> 1588081123.7789369
t1 --------> 1588081123.7980876
t2 --------> 1588081126.7961557
t2 --------> 1588081129.7995002

Je gebruikt ook de methode join, wat betekent dat je wacht tot alle threads klaar zijn met uitvoeren. Alle code die je na de methode join schrijft, wordt pas uitgevoerd zodra deze threads zijn beëindigd.

?t1.join

t1.start()
t2.start()

t1.join()
t2.join()

print("Thread execution is complete!")

t1 --------> 1588081798.7118263
t1 --------> 1588081799.7231226
t2 --------> 1588081800.7129223
t1 --------> 1588081800.730732
t2 --------> 1588081803.7298765
t2 --------> 1588081806.7309563
Thread execution is complete!

Laten we nu het volume van een kubus en een vierkant berekenen met behulp van threading. Dat is vrij eenvoudig.

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!")

Thread execution is complete!


Exception in thread Thread-9:
Traceback (most recent call last):
  File "C:\Program Files\Anaconda3\lib\threading.py", line 926, in _bootstrap_inner
    self.run()
  File "C:\Program Files\Anaconda3\lib\threading.py", line 870, in run
    self._target(*self._args, **self._kwargs)
TypeError: volume_square() argument after * must be an iterable, not int
Exception in thread Thread-8:
Traceback (most recent call last):
  File "C:\Program Files\Anaconda3\lib\threading.py", line 926, in _bootstrap_inner
    self.run()
  File "C:\Program Files\Anaconda3\lib\threading.py", line 870, in run
    self._target(*self._args, **self._kwargs)
TypeError: volume_cube() argument after * must be an iterable, not int

Hè? Zodra je de startmethode uitvoerde, resulteerde dat in een fout. Dat komt doordat de parameter args een tuple verwacht. Omdat volume_cube en volume_square slechts één parameter verwachten, moet je een komma toevoegen in de parameter args nadat je het eerste argument van de functies hebt opgegeven.

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: 8
Volume of Square: 9
Thread execution is complete!

Laten we nu threading gebruiken als subklasse.

Threading als subklasse

In deze sectie leer je hoe je een subklasse maakt van de threadklasse uit de threadingmodule en daaruit threadinstanties t1 en t2 maakt.

Je gebruikt hier ook dezelfde functie thread_delay.

class DataCampThread(threading.Thread):
    def __init__(self, name, delay):
        threading.Thread.__init__(self)
        self.name = name
        self.delay = delay


    def run(self):
        print('Starting Thread:', self.name)
        thread_delay(self.name,self.delay)
        print('Execution of Thread:', self.name, 'is complete!')


t1 = DataCampThread('t1', 1)
t2 = DataCampThread('t2', 3)    

t1.start()
t2.start()

t1.join()
t2.join()

print("Thread execution is complete!")

Starting Thread: t1
Starting Thread: t2
t1 --------> 1588089083.4879806
t1 --------> 1588089084.489222
t1 --------> 1588089085.4909666
Execution of Thread: t1 is complete!
t2 --------> 1588089085.4979634
t2 --------> 1588089088.499365
t2 --------> 1588089091.5012596
Execution of Thread: t2 is complete!
Thread execution is complete!

Nu leggen we bovenstaande code stap voor stap uit:

• Je definieerde een klasse DataCampThread en gaf in het klasseargument de klasse threading.Thread door. Dat doe je omdat je een subklasse van de threadingmodule wilt maken. Hierdoor kun je alle methodes gebruiken die beschikbaar zijn in de klasse threading.Thread, vergelijkbaar met het concept van overerving.

• Vervolgens definieerde je de init-methode van de klasse DataCampThread en gaf je de functie door samen met de vertraging. De init is een constructor, vergelijkbaar met de parameters die je doorgaf aan de klasse threading.Thread; hier geef je ze door aan de klasse DataCampThread.

• Daarna initialiseer je de init-methode van de hoofdklasse threading.Thread en ken je name en delay toe.

• Vervolgens definieer je de methode run. Denk terug aan hier, waar je de methode start definieerde; onder de motorkap roept die de methode run aan. Omdat je de hoofdklasse hebt overgeërfd, mag je wijzigingen aanbrengen in de methode run. Wanneer je dus de methode start aanroept, worden de aanpassingen die je in de methode run hebt gedaan nu doorgevoerd.

Conclusie

Gefeliciteerd met het afronden van de tutorial.

Deze tutorial was een basisintroductie tot threading in Python. Threading is echter een uitgebreid en belangrijk onderwerp, en sommige concepten zijn mogelijk niet aan bod gekomen. Kijk gerust verder naar threadmethodes zoals active count, current thread, enz.

Wil je meer leren? Bekijk dan ook Python’s Thread-based Parallelism.

Ben je net begonnen met Python en wil je meer leren? Volg dan de cursus Introduction to Data Science in Python van DataCamp.