Definitive Guide: Threading in Python (Svenska)

om du bara kommer igång i Python och vill lära dig mer, ta Datacamps introduktion till datavetenskap i Python kurs.

introduktion

gängning gör att du kan ha olika delar av processen körs samtidigt (källa: RealPython). Dessa olika delar är vanligtvis individuella och har en separat enhet för utförande som tillhör samma process., Processen är inget annat än ett löpande program som har enskilda enheter som kan köras samtidigt. Till exempel kan en webbläsare vara en process, ETT program som kör flera kameror samtidigt kan vara en process; ett videospel är ett annat exempel på en process.

inuti en process kommer begreppet multipel gängning eller allmänt känd som multi-threading, där flera trådar arbetar tillsammans för att uppnå ett gemensamt mål. Den mest avgörande fördelen med att använda trådar är att det låter dig köra programmet parallellt.,

låt oss förstå begreppet gängning med hjälp av ett exempel. Tänk dig att du har ett program som räknar antalet bilar som kommer in och lämnar köpcentret parkering. Din apparat har olika kameror som övervakar inmatning och utgång anslutning till en central enhet. Varje kamera kommer att ha en algoritm för att övervaka flödet av bilar, som kommer att tillhöra samma process eller program. Men varje kamera, tillsammans med algoritmen den körs på, kan vara en del av en separat tråd., Inte bara det, men även ramarna som läses från kameran och algoritmen som förutspår ramarna kan också vara två separata trådar.

ett annat exempel kan vara ett videospel där processen måste köra uppgifterna parallellt som grafik, användarinteraktion och nätverk (när du spelar multiplayer-spel) eftersom det måste vara lyhörd hela tiden. Och för att uppnå detta måste det använda sig av begreppet multi-threading, där varje tråd skulle vara ansvarig för att köra varje självständig och individuell uppgift.,

en tråd har sitt flöde av utförande, vilket innebär att processen kommer att ha flera saker som händer på en gång.

det är viktigt att notera att varje process har minst en tråd, och det kallas main thread. Om ditt program inte har någon definierad tråd, så kommer det åtminstone att ha huvudtråden, dvs själva processen.

om du tittar på ovanstående diagram finns det en process som består av huvudtråden bestående av globala variabler och tre olika trådar t1, T2 och t3. Varje tråd har sina lokala variabler och flöde av utförande av kod., Trådarna delar i allmänhet processens resurser, som de resurser som är tillgängliga för huvudtråden kommer också att delas mellan de tre trådarna t1, t2 och t3. Alla trådar kommer att ha tillgång till de globala variablerna samtidigt som de har sina egna lokala variabler.,

det finns olika typer av trådar:

• kärntråd
• Användartråd
• kombination av kärna och användartråd

låt oss nu titta på några av fördelarna med att ha gängning i ditt program:

• multi-threading tillåter programmet att påskynda utförandet förutsatt att det har flera processorer.

• det låter dig också utföra andra uppgifter medan I / O-operationerna utförs med hjälp av flera trådar eller till och med huvudtråd tillsammans med en enda tråd., Till exempel kommer hastigheten vid vilken ramarna från kameran läses och härleds av algoritmen att hanteras av olika trådar. Därför behöver algoritmen inte vänta på att ramen ska matas in, och ramläsningsdelen behöver inte vänta på att algoritmutförandet ska slutföras för att kunna läsa nästa ram.

• trådar inom samma process kan dela minnet och resurserna för huvudtråden.,

utmaningar för gängning:

• Kom ihåg att Python fungerar baserat på CPython-implementeringen, vilket begränsar endast en tråd som ska köras i taget, varför; gängning kanske inte påskyndar alla uppgifter. Och den väsentliga orsaken till detta är Global Interpreter Lock (GIL).

  om du vill lära dig om GIL, är du välkommen att kolla in den här handledningen.

• om du letar efter att påskynda CPU-intensiv uppgift, threading kanske inte den bästa lösningen för dig. I sådana fall anses multibearbetning vara användbar.,

• för att utföra ett program som består av olika trådar måste det snabbt växla över trådar; därför måste schemaläggning tas hand om i program där du har många trådar.

• resursdelning kan också vara ett problem eftersom alla trådar delar samma resurser och minne för de globala variablerna. Därför kan operationer som utförs i en tråd orsaka ett minnesfel för en annan tråd, eller den andra tråden kanske inte får minnet att utföra sin uppgift.,

gängning i Python

• i Python är gängmodulen en inbyggd modul som kallasthreading och kan importeras direkt.

• eftersom nästan allt i Python representeras som ett objekt är threading också ett objekt i Python. En tråd kan

  • hålla data,
  • lagras i datastrukturer som ordböcker, listor, uppsättningar, etc.
  • kan skickas som en parameter till en funktion.

• en tråd kan också utföras som en process.,

• en tråd i Python kan ha olika tillstånd som:

  • vänta,
  • låst.

låt oss nu lära oss hur du kan implementera gängning i Python.

Trådmodul i Python3

Observera att Python3 är bakåtkompatibel medthread – modulen, som finns i Python2. 7. I Python3 kan den importeras som_thread modul. Så, låt oss ta ett exempel och förstå _thread – modulen.,

import _thread #thread module importedimport time #time module

låt oss definiera en funktion som heterthread_delay, som kommer att ta två parametrar som en ingång, dvs namnet på tråden och fördröjningen. Inuti den här funktionen kommer du att:

• definiera en räknare med noll,
• då kommer du att slingra runt med ett tag slinga som kommer att köras i tre gånger,
• inuti while loop, du kommer att sätta time.sleep() för att lägga till fördröjning, kommer denna fördröjning att vara användbar för att förstå utförandet av tråden., Denna fördröjning kommer att vara i sekunder,
• då kommer du att öka din räknare med 1,
• för att se om din trådkörning går smidigt, kommer du att skriva ut namnet på tråden och den tid då tråden exekveras.

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

nu för att lägga till trådfunktionen på ovanstående funktion eller för att köra ovanstående funktion i tråden, skulle du användastart_new_thread – metoden, som finns inuti_thread module.

låt oss se docstring av metodenstart_new_thread.,

?_thread.start_new_thread

låt oss passera in i funktionenthread_delay utan parentes och de två argumenten, dvs. trådnamn och fördröjning (för att visualisera trådutförandet eftersom det är mycket snabbt).

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

från ovanstående utgång kan du se att trådent1 börjar köras först., Under tiden, tråd t2 väntar eftersom det finns en 3-sekunders fördröjning, och så snart denna fördröjning är klar, tråd t2 exekveras, och även fördröjningen för tråd t1 är bara 1 sekund.

låt oss nu ändra fördröjningen av t2 till 5 sekunder, vilket skulle starta t2 efter t1 skulle ha slutat köra eftersom t1 tar bara 3 sekunder att slutföra utförandet.,

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

implementera gängning med Gängmodulen

låt oss använda samma exempel som du använde ovan, men den här gången använder du modulenthreading istället för modulen_thread.

import threadingimport time

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

inutithreading – modulen är enThread – klass, som är en liknande anda somstart_new_thread – funktionen för _thread modul.,

låt oss titta på docstring avThread klass, som tar in flera parametrar som grupp, mål (som en funktion), args, etc.

?threading.Thread

i Trådklasskonstruktören passerar du i målfunktionen thread_delay och argumenten för den funktionen.,

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

i gängmodulen, för att köra eller utföra tråden, använder du metoden start(), som helt enkelt ansvarar för att köra tråden.

?t1.start

t1.start()t2.start()

du kommer också att använda join – metoden, vilket innebär att vänta tills alla tråd exekver-är klar., Så oavsett kod du har skrivit efterjoin – metoden kommer endast att utföras när dessa trådar har avslutats.

?t1.join

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

låt oss nu beräkna volymen kub och kvadrat med gängkonceptet, vilket är ganska rakt framåt.

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

vänta; vad? Så snart du utförde startmetoden resulterade det i ett fel., Det beror på att parametern args förväntar sig en tuple, och eftersom parametern volume_cube och volume_square bara förväntar sig en parameter, måste du därför lägga ett kommatecken i parametern args efter att ha angett det första argumentet för funktionerna.

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!

låt oss nu lära oss att använda gängning som en underklass.,

gängning som underklass

i det här avsnittet får du lära dig hur du skapar underklass från trådklassen, som är tillgänglig inuti gängmodulen, och sedan skapa trådinstansert1 ocht2 utanför den klassen.

du skulle använda sammathread_delay funktion här också.

låt oss nu förstå ovanstående kod steg för steg:

• du definierade en klass som DataCampThread, och i klassargumentet passerade du i klassen threading.Thread., Anledningen till att du gör det är att du vill skapa en underklass från gängmodulen. Genom att göra detta kan du använda alla metoder som finns tillgängliga i klassen threading.Thread som liknar begreppet arv.

• därefter definierade du init-metoden för DataCampThread-klassen och passerade i funktionen tillsammans med fördröjningen. Init är en konstruktör som liknar parametrarna du passerade till klassenthreading.Thread, här skulle du gå vidare till klassenDataCampThread.,

• då initierar du init-metoden för huvudtrådningen.Tråd klass och sedan likställa namn och fördröjning.

• därefter definierar du metodenrun, minns här du definierade metodenstart, som i princip under huven anropar metodenrun. Eftersom du har ärvt huvudklassen får du göra ändringar irun – metoden., Därför, när du ringer start – metoden, kommer alla ändringar du kommer att göra i run – metoden att återspeglas nu.

slutsats

Grattis till att du avslutat handledningen.

denna handledning var en grundläggande introduktion till gängning i python. Threading är dock ett mycket stort och viktigt ämne, och vissa begrepp kan ha lämnats outforskade. Känn dig fri att titta på fler gängmetoder som active count, current threading, etc.

om du vill lära dig mer, Kolla även Pythons Trådbaserade parallellism.,

om du bara kommer igång i Python och vill lära dig mer, ta Datacamps introduktion till datavetenskap i Python-kursen.