Asyncio-biblioteket er introdusert i python 3.4 for å utføre samtidige programmer med en tråd. Dette biblioteket er populært enn andre biblioteker og rammer for sin imponerende hastighet og forskjellige bruksområder. Dette biblioteket brukes i python for å opprette, utføre og strukturere rutiner og håndtere flere oppgaver samtidig uten å gjøre oppgavene parallelt. De viktigste delene av dette biblioteket er definert nedenfor:

Coroutine: Den delen av koden som kan pauses og gjenopptas i skript med flere tråder kalles coroutine. coroutines jobber samarbeidende i flertrådet program. Når en coroutine tar en pause, kan andre coroutine utføre.

Arrangementsløyfe: Den brukes til å starte kjøringen av coroutines og håndtere input / output-operasjoner. Det tar flere oppgaver og fullfører dem.

Oppgave: Utførelsen og resultatet av coroutines er definert av oppgavene. Du kan tilordne flere oppgaver ved hjelp av asyncio-biblioteket og kjøre oppgavene asynkront.

Framtid: Det fungerer som en fremtidig lagring hvor resultatet av coroutines vil lagres etter ferdigstillelse. Dette er nyttig når koroutine trenger å vente på resultatet av annen coroutine.

Hvordan du kan implementere de ovennevnte konseptene i asyncio-biblioteket, vises i denne veiledningen ved hjelp av noen enkle eksempler.

Eksempel 1: Lag én coroutine med en enkelt oppgave

Opprett en fil med navnet async1.py og legg til følgende kode. asyncio-biblioteket importeres for å bruke funksjonene til dette biblioteket. legge til funksjon er erklært for å beregne summen av et bestemt tallområde. Nummerområdet fra 1 til 101 tildeles av oppgaven med ett sekund forsinkelse. Hendelsessløyfen erklæres at den vil kjøre til alle oppgavene til hovedmetoden er fullført. Etter å ha beregnet verdien, vil funksjonen vente i ett sekund og skrive ut resultatet.

importer asyncio
async def add (start, slutt, vent):
#Initialiser sumvariabelen
sum = 0
#Beregn summen av alle tall
for n innen rekkevidde (start, slutt):
sum + = n
# Vent i tildelte sekunder
venter på asyncio.sove (vent)
# Skriv ut resultatet
skriv ut (f'Sum fra start til end er sum ')
async def hoved ():
#Tildel en enkelt oppgave
oppgave = løkke.create_task (legg til (1.101,1))
# Kjør oppgaven asynkront
venter på asyncio.vent ([oppgave])
hvis __name__ == '__main__':
#Declare event loop
sløyfe = asyncio.get_event_loop ()
# Kjør koden til du fullfører hele oppgaven
Løkke.run_until_complete (main ())
#Lukk løkken
Løkke.Lukk()

Produksjon:

$ python3 async1.py

Utgangen viser summen av 1 til 101 som er 5050.

Eksempel 2: Lag flere coroutines

Bruken av asyncio-biblioteket blir ryddet når du kjører flere coroutines samtidig. Opprett en ny fil med navnet async2.py og legg til følgende kode. Tre oppgaver genereres med tre forskjellige områder og venteverdier i hoved() metode. Første oppgave vil beregne summen fra 5 til 500000 ved å vente i 3 sekunder, den andre oppgaven vil beregne summen fra 2 til 300000 ved å vente i 2 sekunder, og den tredje oppgaven vil beregne summen fra 10 til 1000 ved å vente 1 sekund. Oppgaven med lave venteverdier vil fullføres først, og oppgaven med høy venteverdi vil til slutt fullføres.

importer asyncio
async def add (start, slutt, vent):
#Initialiser sumvariabelen
sum = 0
# Beregn summen av alle tall
for n innen rekkevidde (start, slutt):
sum + = n
# Vent i tildelte sekunder
venter på asyncio.sove (vent)
# Skriv ut resultatet
skriv ut (f'Sum fra start til end er sum ')
async def hoved ():
#Tildel første oppgave
oppgave1 = løkke.create_task (legg til (5.500.000,3))
#Tildel andre oppgave
oppgave2 = løkke.create_task (legg til (2.300.000,2))
#Tildel tredje oppgave
oppgave3 = løkke.create_task (legg til (10,1000,1))
# Kjør oppgavene asynkront
venter på asyncio.vent ([oppgave1, oppgave2, oppgave3])
hvis __name__ == '__main__':
#Declare event loop
sløyfe = asyncio.get_event_loop ()
# Kjør koden til du fullfører hele oppgaven
Løkke.run_until_complete (main ())
#Lukk løkken
Løkke.Lukk()

Produksjon:

$ python3 async1.py

Utgangen viser at oppgave3 er fullført først fordi ventetiden til denne oppgaven var bare 1 sekund og oppgave1 er fullført sist fordi ventetiden til denne oppgaven var 3 sekunder.

Eksempel 3: coroutines med fremtiden

Dette eksemplet viser bruken av fremtidig objekt for asyncio-biblioteket. Opprett en ny fil med navnet async3.py og legg til følgende kode. To oppgaver er tildelt for fremtiden i dette eksemplet. Vis melding funksjonen erklæres her for å skrive ut meldingen før du kjører coroutine og etter at du har fullført kjøringen. Første oppgave vil vente i 2 sekunder og fullføre sist. Andre oppgave venter i 1 sekund og fullføres først.

importer asyncio
async def show_message (nummer, vent):
#Skriv ut meldingen
skriv ut (f'Task number kjører ')
# Vent i tildelte sekunder
venter på asyncio.sove (vent)
skriv ut (f 'Oppgave nummer er fullført')
async def stop_after (når):
venter på asyncio.sove (når)
Løkke.Stoppe()
async def hoved ():
#Tildel første oppgave
oppgave1 = asyncio.sikre_futur (vis_melding (1,2))
skriv ut ('Schedule 1')
#Tildel andre oppgave
oppgave2 = asyncio.sikre_futur (visemelding (2,1))
skriv ut ('Schedule 2')
# Kjør oppgavene asynkront
venter på asyncio.vent ([oppgave1, oppgave2])
hvis __name__ == '__main__':
#Declare event loop
sløyfe = asyncio.get_event_loop ()
# Kjør koden til hovedmetoden til du fullfører hele oppgaven
Løkke.run_until_complete (main ())

Produksjon:

$ python3 async3.py

Det vises i utgangen at oppgave1 startes først og fullføres sist, og oppgave2 startes senere, men fullføres først for kort ventetid.

Konklusjon

Det grunnleggende konseptet med asynkron programmering ved bruk av asyncio-biblioteket til python er forklart her. Håper, du vil være i stand til å skrive kode med flere tråder i python etter å ha praktisert eksemplene på denne opplæringen.