(Tutorial) Definitive Guide: Gjenging i Python

Hvis du er bare komme i gang i Python, og ønsker å lære mer, ta DataCamp Innledningen til Data Vitenskap i Python kurs.

Innledning

Threading lar deg ha forskjellige delene av prosessen kjøres samtidig (Kilde: RealPython). Disse ulike deler er vanligvis individuell og har en egen enhet for gjennomføring som hører til den samme prosessen., Prosessen er ingenting, men et program som kjører som har individuelle enheter som kan kjøre samtidig. For eksempel, En web-leseren, kan være en prosess, et program som kjører flere kameraer samtidig kunne være en prosess, en video game er et annet eksempel på en prosess.

Inne i en prosess kommer konseptet av flere threading eller allment kjent som multi-threading, hvor flere tråder arbeide sammen for å oppnå et felles mål. Den viktigste fordelen med å bruke tråder er at det gir deg mulighet til å kjøre programmet i parallell.,

La oss forstå konseptet av threading med hjelp av et eksempel. Tenk deg at du har et program som teller antall biler inn og går ut av kjøpesenteret er parkering. Din apparatet har ulike kameraer som overvåker entry og exit for å koble til en sentral enhet. Hvert kamera har en algoritme for å overvåke strømmen av biler, som vil tilhøre samme prosess eller et program. Men, hvert kamera, sammen med algoritmen det blir kjørt på, kan være en del av en egen tråd., Ikke bare det, men selv de rammer som blir lest fra kameraet og algoritmen for å predikere på rammer kan også være to separate tråder.

et Annet eksempel kan være en video spill som prosessen har til å kjøre den oppgaver i parallell som grafikk, brukermedvirkning og nettverksbygging (mens du spiller multiplayer spill) fordi det må være lydhør til alle tider. Og for å oppnå dette, det har å gjøre bruk av begrepet multi-threading, hvor hver tråden vil være ansvarlig for å kjøre hver selvstendig og individuell oppgave.,

En tråd har sin flyt på kjøringen, noe som betyr at den prosessen som vil ha flere ting skjer på en gang.

Det er viktig å merke seg at hver prosess har minst én tråd, og som er kalt main thread. Hvis programmet ikke har noen definert tråden, så vil den minst har den viktigste tråden, dvs., selve prosessen.

Hvis du ser på diagrammet ovenfor, det er en prosess som består av de viktigste tråden som består av globale variabler og tre forskjellige tråder t1, t2 og t3. Hver tråd har sitt lokale variabler, og flyten av kjøring av kode., Trådene generelt dele ressurser av prosessen, som de ressurser som er tilgjengelig for de viktigste tråden vil også bli delt mellom tre tråder t1, t2 og t3. Alle trådene vil ha tilgang til de globale variablene, mens det å ha sin egen lokale variabler.,

Det finnes forskjellige typer tråder:

Kernel tråden
Bruker tråden
Kombinasjon av kernel og bruker tråden

la oss Nå se på noen av fordelene med å ha gjenging i programmet:

Multi-threading lar programmet til å fremskynde gjennomføringen forutsatt at det har flere Prosessorer.
Det kan du også utføre andre oppgaver mens den i/O-operasjoner blir utført med hjelp av flere tråder eller selv viktigste tråden langs med en eneste tråd., For eksempel, den hastigheten som rammer fra kameraet er lest og utledes av algoritmen vil bli håndtert av forskjellige tråder. Derfor, algoritmen vil ikke vente på bildet for å bli lagt inn, og rammen for å lese del ikke må vente for kjøring av algoritmen for å fullføre for å være i stand til å lese det neste bildet.

Tråder i den samme prosessen kan dele minne og ressurser i hovedtråden.,

Utfordringer Threading:

Husk at Python verk basert på CPython implementering, noe som begrenser bare en tråd for å kjøre på en gang, derfor; threading kan ikke fart opp alle oppgaver. Og den avgjørende årsaken bak dette er Globale Tolk Lås (GIL).

Hvis du ønsker å lære om GIL, så føl deg fri til å sjekke ut denne opplæringen.
Hvis du er ute for å påskynde CPU-intensive oppgaven, så threading kan ikke være den beste løsningen for deg. I slike tilfeller, multi-behandling er ansett for å være nyttig.,
for Å utføre et program bestående av ulike tråder, er det behov for å bytte raskt på tvers av tråder; derav, planlegging trenger å bli tatt vare på i programmer der du har en masse av tråder.
Ressurs-deling kan også være et problem siden alle trådene har de samme ressursene og minnet av den globale variabler. Derfor, operasjoner utført i en tråd kan føre til en minne-feil for en annen tråd, eller den andre tråden kan ikke få minne til å utføre sin oppgave.,

Gjenging i Python

I Python, og gjenging-modulen er en innebygd modul som er kjent som threading og kan importeres direkte.
Siden nesten alt i Python er representert som et objekt, gjenging også er et objekt i Python. En tråd er i stand til
- Holding data,
- er Lagret i data-strukturer som ordbøker, lister, sett, etc.
- Kan sendes som en parameter til en funksjon.
En tråd kan også utføres som en prosess.,
En tråd i Python kan ha ulike tilstander som:
- Vent,
- Låst.

La oss nå lære hvordan du kan implementere gjenging i Python.

Tråden modul i Python3

Merk at Python3 er bakover kompatibel med thread modul, som finnes i Python2.7. I Python3, det kan bli importert som _thread modulen. Så, la oss ta et eksempel og korrekt _thread modulen.,

import _thread #thread module importedimport time #time module

La oss definere en funksjon som kalles thread_delay, som tar to parametere som en inngang, dvs., navnet på gjenger og forsinkelse. Inne i denne funksjonen, vil du:

Definere en teller med null,
Da vil du sløyfe rundt med en while-løkke som vil kjøre for tre ganger,
i mens loop, vil du sette time.sleep() for å legge til forsinkelse, denne forsinkelsen vil være nyttig for å forstå gjennomføring av tråden., Denne forsinkelsen vil være i sekunder,
Så du vil øke din counter ved 1,
for Å se om din tråden gjennomføring er å gå jevnt, du vil skrive ut navnet på tråden og til hvilken tid tråden er utført.

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

Nå å legge til tråden funksjonalitet på de ovennevnte funksjon eller å kjøre ovenfor funksjon i tråden, vil du bruke start_new_thread metode, som er inne i _thread module.

La oss se docstring av start_new_thread metode.,

?_thread.start_new_thread

La oss passere i funksjon thread_delay uten parenteser, og de to argumenter, dvs., tråd navn og forsinkelse (for å visualisere tråden gjennomføring siden det er veldig fort).

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

Fra over utgang, kan du se at tråden t1 begynner å kjøre først., I mellomtiden tråden t2 venter siden det er et 3-sekunders forsinkelse, og så snart at forsinkelsen er ferdig, tråden t2 er utført, og også forsinkelse for tråden t1 er bare 1 sekund.

La oss nå endre forsinkelsen av t2 5 sekunder, noe som ville starte t2 etter t1 ville ha ferdig utfører siden t1 tar bare 3 sekunder for å fullføre sin kjøring.,

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

Implementering threading med Threading-modulen

La oss bruke det samme eksemplet som du har brukt ovenfor, men denne gangen vil du bruke threading modulen i stedet for _thread modulen.

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 modulen er en Thread klasse, som er et lignende ånd til start_new_thread funksjon _thread modulen.,

La oss se på docstring av Thread klasse, som tar inn flere parametere som gruppe, mål (som en funksjon), args, etc.

?threading.Thread

I Tråd klasse konstruktør, vil du passere i mål funksjon thread_delay og argumenter som fungerer.,

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

I threading-modulen for å kjøre eller utføre tråden, kan du gjøre bruk av start() metode, som rett og slett er ansvarlig for driften av tråden.

?t1.start

t1.start()t2.start()

Du vil også bruke join – metoden, som innebærer at vente til alle tråd gjennomføring er fullført., Så uansett hva koden du har skrevet etter join metoden vil bare bli utført når disse gjengene har avsluttet.

?t1.join

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

la oss Nå beregne volumet av kuben og torget ved hjelp av tråder-konseptet, som er ganske rett frem.

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, hva? Så snart du har utført start-metoden, det resulterte i en feil., Det er fordi args parameter forventer en tuple, og siden volume_cube og volume_square forventer kun én parameter, derav, du trenger å sette et komma i args parameter etter å spesifisere det første argumentet av funksjoner.

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!

La oss nå lære å bruke threading som en underklassen.,

Threading som en sub-klasse

I denne delen, vil du lære hvordan å lage sub-klasse fra tråden klasse, som er tilgjengelig inne i threading-modulen, og trykk deretter opprette tråden tilfeller t1 og t2 ut av klassen.

Du vil bruke samme thread_delay fungere her også.

la oss Nå forstå koden ovenfor trinn for trinn:

Du har definert en klasse som DataCampThread, og i klasse argument, du gått i threading.Thread klasse., Grunnen til at du gjør det er at du ønsker å opprette en sub-klasse fra threading-modulen. Å gjøre dette kan du bruke alle metodene som er tilgjengelige i threading.Thread klasse ligner på konseptet av arv.
Neste, du har definert init-metoden for DataCampThread klasse og gikk i funksjon sammen med forsinkelse. Init er en konstruktør som ligner de parameterne som sendes til threading.Thread klasse, her du ville være passere til DataCampThread klasse.,
Så du initialisere init-metoden av de viktigste gjenging.Tråden klassen, og sidestiller navn og forsinkelse.
Neste, du definere run metode, husker du her definert start metode, som i utgangspunktet under panseret anrop run metode. Siden du har arvet den viktigste klassen, har du lov til å gjøre endringer til run metode., Derfor, når du ringer start metode, uansett hvilke endringer du vil gjøre i run metode vil bli reflektert nå.

Konklusjon

Gratulerer med etterbehandling opplæringen.

Denne opplæringen var en grunnleggende introduksjon til gjenging i python. Imidlertid, threading er et veldig stort og viktig tema, og noen begreper kan ha blitt til uutforsket. Føl deg fri til å se på mer threading metoder som aktiv telle, gjeldende tråden, etc.

Hvis du ønsker å lære mer, så sjekk også ut Python ‘ s Thread-basert Parallellitet.,