Tijd is de meest kritische factor in het leven. Vanwege het belang ervan, biedt de programmeerwereld verschillende trucs en technieken die u aanzienlijk helpen om het tijdverbruik te verminderen en zo de prestaties te verbeteren. Een van die benaderingen is Multithreading in Python, een van de belangrijkste concepten die hieronder worden behandeld .
Hier is een korte samenvatting van alle majors die in dit artikel worden behandeld:
hoe een object in python te initialiseren
Wat is multitasking in Python?
Wat is een thread?
Wat is multithreading in python?
Wanneer multithreading in Python gebruiken?
Hoe multithreading in Python te bereiken?
Hoe maak je threads in Python?
Voordelen van het gebruik van multithreading in Python
Laten we om te beginnen eerst proberen multitasking te begrijpen voordat we beginnen te leren over Multithreading in Python.
Wat is multitasking in Python?
Multitasking is in het algemeen de mogelijkheid om meerdere taken tegelijk uit te voeren. In technische termen verwijst multitasking naar het vermogen van een besturingssysteem om verschillende taken tegelijkertijd uit te voeren. Bijvoorbeeld , u downloadt iets op uw pc, luistert naar liedjes en speelt tegelijkertijd een spel, enz. Al deze taken worden gesynchroniseerd uitgevoerd door hetzelfde besturingssysteem. Dit is niets anders dan multitasking, waarmee u niet alleen tijd bespaart, maar ook de productiviteit verhoogt.
Er zijn twee soorten multitasking in een besturingssysteem:
- Procesmatig
- Op draad gebaseerd
In dit artikel leer je over Op draad gebaseerd multitasking of Multithreading .
Wat is een thread?
Een thread is eigenlijk een onafhankelijk stroom van uitvoering. Een enkel proces kan uit meerdere threads bestaan. Elke thread in een programma voert een bepaalde taak uit. Bijvoorbeeld, als je een game speelt, bijvoorbeeld FIFA op je pc, is de game als geheel één proces , maar het bestaat uit verschillende threads die verantwoordelijk zijn voor het afspelen van de muziek, input van de gebruiker ontvangen, de tegenstander synchroon laten lopen, enz. Dit zijn allemaal afzonderlijke threads die verantwoordelijk zijn voor het uitvoeren van deze verschillende taken in hetzelfde programma.
Elk proces heeft één thread die altijd actief is. Dit is de rode draad. Deze hoofdthread maakt eigenlijk de onderliggende thread-objecten. De child-thread wordt ook geïnitieerd door de hoofd-thread. Ik zal jullie allemaal verder in dit artikel laten zien hoe je de huidige lopende thread kunt controleren.
Dus hiermee hoop ik dat je duidelijk hebt begrepen wat een rode draad is. Laten we verder kijken wat Multithreading is in Python.
Wanneer gebruik je Multithreading in Python?
Multithreading is erg handig om tijd te besparen en de prestaties te verbeteren, maar het kan niet overal worden toegepast.
In het vorige FIFA-voorbeeld is de muziekthread onafhankelijk van de thread die jouw input ontvangt en de thread die jouw input ontvangt, is onafhankelijk van de thread die je tegenstander bestuurt. Deze threads werken onafhankelijk omdat ze niet onderling afhankelijk zijn.
Daarom kan multithreading alleen worden gebruikt als de afhankelijkheid tussen individuele threads niet bestaat.
Dit artikel laat verder zien hoe u Multithreading in Python kunt bereiken.
Hoe multithreading in Python te bereiken?
Multithreading in Python kan worden bereikt door het draadsnijden module.
Voordat u deze module importeert, moet u deze eerst installeren. Om dit op je anaconda-omgeving te installeren, voer je de volgende opdracht uit op je anaconda-prompt:
conda install -c conda-forge tbb
Nadat het met succes is geïnstalleerd, kunt u een van de volgende opdrachten gebruiken om de threading-module te importeren:
threading importeren uit threading importeren *
Nu je de threading-module hebt geïnstalleerd, gaan we verder en doen we Multithreading in Python.
Hoe maak je threads in Python?
Threads in Python kunnen op drie manieren worden gemaakt:
- Zonder een klas te creëren
- Door Thread class uit te breiden
- Zonder de Thread-klasse uit te breiden
Zonder een klas te creëren
Multithreading in Python kan worden bereikt zonder ook een klasse te maken. Hier is een voorbeeld om hetzelfde te demonstreren:
Voorbeeld:
van threading import * print (current_thread (). getName ()) def mt (): print ('Child Thread') child = Thread (target = mt) child.start () print ('Threadnaam uitvoeren:', current_thread ( ) .getName ())Uitgang:
MainThread Child Thread Naam van de thread uitvoeren: MainThreadUit bovenstaande output blijkt dat de eerste draad die aanwezig is, de rode draad is. Deze hoofdthread maakt dan een kindthread die de functie uitvoert en vervolgens wordt de laatste printopdracht opnieuw uitgevoerd door de hoofdthread.
Laten we nu verder gaan en kijken hoe we Multithreading in python kunnen doen door de Thread-klasse uit te breiden.
Door de Thread-klasse uit te breiden:
Wanneer een onderliggende klasse wordt gemaakt door de Thread-klasse uit te breiden, geeft de child-klasse aan dat een nieuwe thread een taak uitvoert. Bij het uitbreiden van de Thread-klasse kan de child-klasse slechts twee methoden overschrijven, namelijk de __init __ () methode en de run () methode. Geen enkele andere methode kan worden overschreven behalve deze twee methoden.
Hier is een voorbeeld van hoe u de klasse Thread kunt uitbreiden om een thread te maken:
hoe de gekoppelde lijst in c
Voorbeeld:
import threading import tijd klasse mythread (threading.Thread): def run (self): for x in range (7): print ('Hallo van kind') a = mythread () a.start () a.join () print ('Tot ziens van', current_thread (). GetName ()) Uitgang:
Hallo van kind
Hallo van kind
Hallo van kind
Hallo van kind
Hallo van kind
Hallo van kind
Hallo van kind
Tot ziens van MainThread
Het bovenstaande voorbeeld laat zien dat class myclass de Thread-klasse erft en de child class, d.w.z. myclass, de run-methode overschrijft. Standaard moet de eerste parameter van elke klassefunctie self zijn, wat de pointer naar het huidige object is. De uitvoer laat zien dat de onderliggende thread de methode run () uitvoert en de hoofdthread wacht tot de uitvoering van de child is voltooid. Dit komt door de functie join (), waardoor de hoofdthread wacht tot het kind klaar is.
Deze methode voor het maken van threads heeft de meeste voorkeur omdat dit de standaardmethode is. Maar als u threads wilt maken zonder de Thread-klasse te erven of uit te breiden, kunt u dit op de volgende manier doen.
Zonder de Thread-klasse uit te breiden
Om een thread te maken zonder de Thread-klasse uit te breiden, doet u het volgende:
Voorbeeld:
sorteermatrix c ++ oplopend
van threading import * class ex: def myfunc (self): #self noodzakelijk als eerste parameter in een class func voor x in bereik (7): print ('Child') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('done')Uitgang:
Kind
Kind
Kind
Kind
Kind
Kind
Kind
gedaan
Voordelen van draadsnijden
Multithreading heeft veel voordelen, waaronder de volgende:
- Betere benutting van middelen
- Vereenvoudigt de code
- Maakt gelijktijdig en parallel optreden van verschillende taken mogelijk
- Vermindert het tijdverbruik of de responstijd, waardoor de prestaties toenemen.
Hier is een voorbeeld om te controleren hoe lang het duurt voordat een code wordt uitgevoerd met en zonder multithreading in python:
Voorbeeld: import tijd def sqr (n): voor x in n: tijd.sleep (1) x% 2 def kubus (n): voor x in n: tijd.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) cube (n) e = time.time () print (es)
Uitgang:
16.042309284210205
Het bovenstaande is de uitvoertijd die nodig is om het programma uit te voeren zonder threads te gebruiken. Laten we nu threads gebruiken en kijken wat er met hetzelfde programma gebeurt:
Voorbeeld:
threading importeren uit threading import * import tijd def sqr (n): voor x in n: time.sleep (1) print ('Rest na delen door 2', x% 2) def cube (n): voor x in n: time.sleep (1) print ('Rest na delen door 3', x% 3) n = [1,2,3,4,5,6,7,8] start = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Thread (target = kubus, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () end = time.time () print (end-start) Uitgang: 9.040220737457275 De bovenstaande uitvoer laat duidelijk zien dat de tijd die nodig is wanneer we threads gebruiken veel minder is in vergelijking met de tijd die nodig is om hetzelfde programma uit te voeren zonder threads te gebruiken.
Ik hoop dat je duidelijk bent met de concepten die in dit artikel worden behandeld met betrekking tot Multithreading in Python. Zorg ervoor dat u zoveel mogelijk oefent, want dit is een van de belangrijkste concepten die bij het programmeren worden gebruikt.
Heeft u een vraag voor ons? Vermeld het alstublieft in de commentarensectie van deze 'Multithreading in Python' blog en wij zullen neem zo snel mogelijk contact met u op.
Om diepgaande kennis op te doen over Python en de verschillende applicaties, kunt u zich live inschrijven met 24/7 ondersteuning en levenslange toegang.