Python multithreading

“Innenfor en prosess er en utførelsesenhet kjent som en tråd. Ved å raskt flytte CPUs oppmerksomhet mellom tråder, kan mange tråder kjøres samtidig i en prosess kjent som multithreading (også kalt kontekstbryter). Det grunnleggende om Python multithreading vil bli dekket i denne artikkelen. For din hjelp vil vi også gi en rekke eksempler.”

Multithreading i Python

Multithreading er en trådteknikk som brukes i Python -programmering for å kjøre mange tråder samtidig. I tillegg muliggjør det deling av dataområdet med de primære trådene i en prosess, som lettere deler informasjon enn separate prosesser. Målet med multithreading er å utføre en rekke prosesser samtidig, noe som forbedrer applikasjonens gjengivelse og ytelse.

Det er en veldig praktisk metode for å få fart på og forbedre funksjonaliteten til en applikasjon. Ved å bruke multithreading kan en programmerer dele ned applikasjonsoppgaver i mindre jobber og kjøre flere forekomster av programmet på en gang. Det gjør det mulig for tråder å kommunisere med hverandre og dele prosessorressurser, inkludert minne, filer og data. I tillegg gjør det brukerne mer villige til å fortsette å bruke et program selv når en del av det er blokkert eller for lenge.

Eksempel 1

Her er et enkelt Python -program for multithreading. La oss se på et Python -program som har to klasser, “Python_Demo” og “Python_lesson.”La oss se på denne prøvekoden i detalj.

To av klassene våre bruker lignende teknikker. Utgangen fra løpsfunksjonen til førsteklasses objekt når den er konstruert og skrevet ut uttrykket “Python Demo” fire ganger. Ordet “python leksjon” vises fire ganger når vi gjentar prosessen for andre klasse.

Klasse Python_Demo:
def run (selv):
for jeg i rekkevidde (4):
trykk ("Python Demo")
Klasse Python_lesson:
def run (selv):
for jeg i rekkevidde (4):
Print ("Python Lesson")
first_obj = python_demo ()
Second_OBJ = Python_lesson ()
FIRST_OBJ.løpe()
Second_obj.løpe()

Utfallet hvis vi kjører dette programmet er som følger. Python Demo og Python -leksjon vises fire ganger etter hverandre, som du kan se. Som et resultat er hovedtråden der dette programmet kjører. Hvert program inneholder hovedtråden. I dette tilfellet utføres begge operasjonene i en sekvens.

Eksempel 2

Vi bruker Pythons trådmodul som et eksempel. Vi forstår kanskje nødvendigheten av multithreading hvis vi vurderer det første scenariet. Det innebærer at begge prosedyrene må brukes samtidig. Pythons trådklasse og trådpakke kan brukes til å oppnå dette. La oss prøve å tenke på noe. Nå som multithreading er til stede, er prøveprogrammet oppdatert. I tillegg ble hver klasse kjørt som sin egen tråd ved bruk av trådklassen.

Vi gjorde også en forskjell ved ikke direkte å ringe løpsmetoden. I stedet benytter vi oss av startmetoden, som i utgangspunktet er tråden implementeringsmekanismen.

Når vi bruker startmetoden, kalles kjøringsfunksjonen øyeblikkelig i bakgrunnen. Vi utfører for øyeblikket hovedtråden som standard. To barnetråder, første OBJ, og andre OBJ, dannes når startmetodene kalles.

Fra å trekke import *
Klasse Python_Demo (tråd):
def run (selv):
for jeg i rekkevidde (4):
trykk ("Python Demo")
Klasse Python_lesson (tråd):
def run (selv):
for jeg i rekkevidde (4):
Print ("Python Lesson")
first_obj = python_demo ()
Second_OBJ = Python_lesson ()
FIRST_OBJ.start()
Second_obj.start()

Disse justeringene resulterer i utgangen som vises nedenfor. Nå som applikasjonen kjører, kan multithreading sees å skje. Vi kan se at flere ord er gruppert sammen, til tross for at "Python Demo" og "Python Lesson" er to separate setninger. Dette ble resultatet av en kollisjon. Det skjer som et resultat av to tråder (first_obj og second_obj) som prøver å utføre på CPU samtidig på grunn av prosessorens overdreven hastighet.

Eksempel 3

Planleggere i operativsystemet spesifiserer tiden for utførelse. I dette eksemplet blir instruksjonene utført av programvaren mer enn en gang på et bestemt tidspunkt.

Vi kan forhindre dette ved å bruke søvntilnærmingen for å gi en liten forsinkelse til programvaren vår. For å oppnå dette, må vi importere søvnfunksjonen fra tidsmodulen for å legge til en kort pause mellom de to trådenes utførelse. Bortsett fra tillegg av søvnfunksjonen, er koden tilnærmet identisk med eksemplene fra før.

Legg merke til de nødvendige modulene, tråden og søvn. Disse modulene importeres først. Søvnfunksjonen blir deretter utført i to klasser som senere er konstruert. For å skrive ut setningen et visst antall ganger i vår sak, tre-vi har brukt for-loopen i begge klasser. For å kjøre applikasjonen, påkalte vi start () -metoden etter implementering av trådtilnærmingen. Programmets endelige kodelinjer demonstrerer dette.

Fra å trekke import *
Fra tid importer søvn
Klasse Python_Demo (tråd):
def run (selv):
for jeg i rekkevidde (3):
trykk ("Python Demo")
søvn (1)
Klasse Python_lesson (tråd):
def run (selv):
for jeg i rekkevidde (3):
Print ("Python Lesson")
søvn (1)
first_obj = python_demo ()
Second_OBJ = Python_lesson ()
FIRST_OBJ.start()
søvn (0.3)
Second_obj.start()

Resultatet viser nå at trådene kjører samtidig.

Eksempel 4

Gjengemodulen i Python brukes til å konstruere tråder i følgende kodebit. Hovedtråden kjøres i koden, og ordene “Dette er hovedtråden” skrives ut. Den første tråden og den andre tråden er to nyetablerte og løpende tråder. Det er en kontekstovergang, og den første tråden begynner å løpe.

Den første tråden legger seg etter de fire første iterasjonene, mens den andre tråden begynner å fungere og fullfører akkurat i tide for neste kontekstbryter.

CPU er nå under kontroll av hovedtråden, som skriver “hovedtråd igjen!”

Den andre tråden gjenopptar utførelsen etter en annen kontekstbryter og fullfører. Hovedtråden kan ikke lenger utføre flere instruksjoner; Derfor slutter programmet.

Importer tråd som TD
Importer tid som t
def print_welcome ():
for jeg i rekkevidde (5):
Hvis jeg == 4:
t.søvn (2)
trykk ("Velkommen")
def print_integers (n):
for i i rekkevidde (n+1):
trykk (i)
trykk ("Dette er hovedtråden.")
first_thread = td.Tråd (mål = print_welcome, args = ())
Second_Thread = TD.Tråd (mål = print_Integers, args = (10,))
First_thread.start()
Second_Thread.start()
trykk ("Hovedtråd igjen!")

Du kan se utgangen i dette avsnittet, der hovedtråden kjøres først, og meldingen gjentas etter behov. Etter utførelsen av den andre tråden, som viste tallene, returnerte programvaren til den første tråden og utførte funksjonen som viser ordet “Velkommen.”

Konklusjon

Temaet for denne artikkelen var Python Multithreading. Ved å raskt bytte mellom tråder ved bruk av en CPU, er multithreading en trådteknikk som brukes i Python -programmering for å kjøre mange tråder samtidig. I tillegg muliggjør det deling av dataområdet med de primære trådene i en prosess, som lettere deler informasjon enn separate prosesser. Målet med multithreading er å utføre en rekke prosesser samtidig.