Definitive Guide: Threading in Python (Dansk)

Hvis du lige er kommet i gang i Python og gerne vil lære mere, skal du tage Datacamps Introduktion til datavidenskab i Python-kursus.

Indledning

Threading giver dig mulighed for at have forskellige dele af din proces til at køre sideløbende (Kilde: RealPython). Disse forskellige dele er normalt individuelle og har en separat udførelsesenhed, der tilhører den samme proces., Processen er intet andet end et kørende program, der har individuelle enheder, der kan køres samtidigt. For eksempel kan en browebbro .ser være en proces, ET program, der kører flere kameraer samtidigt, kan være en proces; et videospil er et andet eksempel på en proces.

inde i en proces kommer begrebet multiple threading eller almindeligvis kendt som multi-threading, hvor flere tråde arbejder sammen for at nå et fælles mål. Den mest afgørende fordel ved at bruge tråde er, at det giver dig mulighed for at køre programmet parallelt.,

lad os forstå begrebet threading ved hjælp af et eksempel. Forestil dig, at du har en applikation, der tæller antallet af biler, der kommer ind og forlader indkøbscenterets parkering. Dit apparat har forskellige kameraer, der overvåger indgang og udgang tilslutning til en central enhed. Hvert kamera vil have en algoritme til at overvåge strømmen af biler, som vil tilhøre den samme proces eller program. Imidlertid kan hvert kamera sammen med den algoritme, det køres på, være en del af en separat tråd., Ikke kun det, men selv de rammer, der læses fra kameraet, og algoritmen, der forudsiger rammerne, kan også være to separate tråde.et andet eksempel kan være et videospil, hvor processen skal køre opgaverne parallelt som grafik, brugerinteraktion og netværk (mens du spiller multiplayer-spil), fordi det altid skal være lydhør. Og for at opnå dette, det har at gøre brug af begrebet multi-threading, hvor hver tråd ville være ansvarlig for at køre hver uafhængig og individuel opgave.,

en tråd har sin strøm af udførelse, hvilket betyder, at processen vil have flere ting sker på .n gang.

det er vigtigt at bemærke, at hver proces har mindst en tråd, og det kaldes main thread. Hvis dit program ikke har nogen defineret tråd, vil det i det mindste have hovedtråden, dvs.selve processen.

Hvis du ser på ovenstående diagram, er der en proces, der består af hovedtråden bestående af globale variabler og tre forskellige tråde t1, t2 og T3. Hver tråd har sine lokale variabler og strøm af udførelse af kode., Trådene deler generelt ressourcerne i processen, ligesom de ressourcer, der er tilgængelige for hovedtråden, også vil blive delt mellem de tre tråde t1, T2 og T3. Alle tråde vil have adgang til de globale variabler, mens de har deres egne lokale variabler.,

Der er forskellige typer af tråde:

• Kernen tråd
• Bruger tråd
• Kombination af kerne og bruger tråd

lad os Nu se på nogle af de fordele, der er ved gevindskæring i dit program:

• Multi-threading giver programmet til at fremskynde udførelsen, forudsat at det har flere Cpu ‘ er.

• det giver dig også mulighed for at udføre andre opgaver, mens I/O-operationerne udføres ved hjælp af flere tråde eller endda hovedtråd sammen med en enkelt tråd., For eksempel håndteres den hastighed, hvormed rammerne fra kameraet læses og udledes af algoritmen, af forskellige tråde. Derfor behøver algoritmen ikke at vente på, at rammen skal indtastes, og rammelæsningsdelen behøver ikke at vente på, at algoritmen udføres for at kunne læse den næste ramme.

• tråde inden for samme proces kan dele hukommelsen og ressourcerne i hovedtråden.,

udfordringer med Threading:

• Husk, at Python fungerer baseret på CPython-implementeringen, hvilket kun begrænser en tråd, der skal køres ad gangen, og dermed; threading kan ikke fremskynde alle opgaver. Og den væsentlige årsag bag dette er Global Interpreter Lock (GIL).

  Hvis du gerne vil lære om GIL, så er du velkommen til at tjekke denne tutorial.

• Hvis du leder efter at fremskynde den CPU-intensive opgave, er threading muligvis ikke den bedste løsning for dig. I sådanne tilfælde anses multi-behandling for at være nyttig.,

• for at udføre et program bestående af forskellige tråde skal det skifte hurtigt på tværs af tråde; derfor skal planlægning tages hånd om i programmer, hvor du har mange tråde.ressourcedeling kan også være et problem, da alle tråde deler de samme ressourcer og hukommelse af de globale variabler. Derfor kan operationer udført i en tråd forårsage en hukommelsesfejl for en anden tråd, eller den anden tråd får muligvis ikke hukommelsen til at udføre sin opgave.,

Gevinddrejning i Python

• I Python, threading modul er et indbygget modul, der er kendt som threading og kan importeres direkte.

• da næsten alt i Python er repræsenteret som et objekt, er threading også et objekt i Python. En tråd er i stand til

  • at holde data,
  • gemt i datastrukturer som ordbøger, lister, sæt osv.
  • kan overføres som en parameter til en funktion.

• en tråd kan også udføres som en proces.,

• en tråd i Python kan have forskellige tilstande som:

  • vent,
  • låst.

lad os nu lære, hvordan du kan implementere threading i Python.

Tråd-modul i Python3

Bemærk, at Python3 er bagud kompatibel med thread modul, som findes i Python2.7. I Python3 kan den importeres som_thread modul. Så lad os tage et eksempel og forstå _thread modul.,

import _thread #thread module importedimport time #time module

lad os definere en funktion kaldet thread_delay, som vil tage to parametre som input, dvs.trådens navn og forsinkelsen. Inde i denne funktion, vil du:

• Angiv en tæller med nul,
• du vil Derefter loop rundt med en while-løkke, der vil løbe over tre gange,
• Inde i while-løkken, du vil lægge time.sleep() for at tilføje en forsinkelse, er denne forsinkelse vil være nyttigt at forstå, udførelse af tråden., Denne forsinkelse vil være i sekunder,
• så øger du din tæller med 1,
• for at se, om din trådudførelse går glat, vil du udskrive navnet på tråden og det tidspunkt, hvor tråden udføres.

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

Nu for at tilføje tråden funktionalitet på ovenstående funktion eller til at køre ovenstående funktion i den tråd, du vil bruge start_new_thread metode, som er inde i en _thread module.

lad os se docstring af start_new_thread – metoden.,

?_thread.start_new_thread

Lad os passere i funktion thread_delay uden parentes, og de to argumenter, dvs, tråd navn og forsinkelse (til at visualisere tråd udførelse, da det er meget hurtigt).

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

Fra ovenstående output, du kan se, at tråden t1 begynder udførelse første., I mellemtiden tråd t2 venter, da der er en 3-sekunders forsinkelse, og så snart, at forsinkelsen er færdig, tråd t2 er udført, og også den forsinkelse for tråd t1 der er kun 1 sekund.

Lad os nu ændre forsinkelsen af t2 til 5 sekunder, hvilket ville starte t2 efter t1 ville have færdigudført, da t1 tager kun 3 sekunder til at afslutte sin udførelse.,

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

Gennemførelse threading hjælp Threading-modul

Lad os bruge det samme eksempel som du har brugt ovenfor, men denne gang du vil bruge threading modul i stedet for _thread modul.

import threadingimport time

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

i threading modul er en Thread class, som er en lignende ånd til start_new_thread funktion _thread modul.,

Lad os se på docstring af Thread class, som tager flere parametre som gruppe, mål (som en funktion), args osv.

?threading.Thread

I Tråd klasse constructor, vil du passere i målet funktion thread_delay og de argumenter, der fungerer.,

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

i gevindmodulet bruger du start() metoden, som simpelthen er ansvarlig for at køre tråden.

?t1.start

t1.start()t2.start()

Du vil også bruge join metode, hvilket betyder, at vente, indtil alle gevind udførelse er afsluttet., Så uanset hvilken kode du har skrevet efter join metoden vil kun blive udført, når disse tråde er afsluttet.

?t1.join

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

lad os Nu beregne volumen af en terning, og pladsen hjælp threading koncept, som er ret straight-forward.

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

Vent, hvad? Så snart du udførte startmetoden, resulterede det i en fejl., Det er fordi args parameter forventer en tupel, og da volume_cube og volume_square forventer, at det kun er én parameter, derfor, er du nødt til at sætte komma i args parameter efter angivelse af det første argument af funktioner.

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!

Lad os nu lære at bruge threading som en underklasse.,

Threading som en sub-klasse

I dette afsnit vil du lære at oprette sub-klasse fra thread klassen, der er til rådighed inden for det threading-modulet, og derefter oprette tråd tilfælde t1 og t2 ud af denne klasse.

du vil også bruge den samme thread_delay funktion her.

lad os Nu forstå ovenstående kode, trin for trin:

• Du har defineret en klasse som DataCampThread, og i klassen argument, du har bestået i threading.Thread class., Grunden til at du gør det er, at du vil oprette en underklasse fra threading-modulet. Ved at gøre dette kan du bruge alle de metoder, der er tilgængelige i threading.Thread klasse svarende til arvebegrebet.

• derefter definerede du init-metoden for datacampthread-klassen og bestod funktionen sammen med forsinkelsen. Init er en konstruktør, der ligner de parametre, du har overført til threading.Thread klasse, her vil du passere til DataCampThread klasse.,

• derefter initialiserer du init-metoden til hovedtrådningen.Tråd klasse og derefter sidestille navn og forsinkelse.

• Næste, kan du definere run metode, mindes du har defineret start metode, som dybest set under kølerhjelmen opkald run metode. Da du har arvet hovedklassen, har du lov til at foretage ændringer i run metoden., Når du kalder start – metoden, vil de ændringer, du vil foretage i run – metoden, blive afspejlet nu.

konklusion

Tillykke med at have afsluttet selvstudiet.

denne tutorial var en grundlæggende introduktion til threading i python. Imidlertid er trådning et meget stort og vigtigt emne, og nogle begreber kan have været uudforsket. Du er velkommen til at se på flere threading metoder som aktiv tæller, nuværende tråd, etc.

Hvis du gerne vil lære mere, så tjek også Pythons trådbaserede parallelisme.,

Hvis du lige er kommet i gang i Python og gerne vil lære mere, skal du tage Datacamps Introduktion til datavidenskab i Python-kursus.