Phenquestions
Coroutine: Het deel van de code dat kan worden gepauzeerd en hervat in multi-threaded script wordt coroutine genoemd. coroutines werken samen in een multi-threaded programma. Wanneer een coroutine pauzeert, kan de andere coroutine uitvoeren.
Evenementenlus: Het wordt gebruikt om de uitvoering van coroutines te starten en invoer-/uitvoerbewerkingen af te handelen. Er zijn meerdere taken nodig en voltooi ze.
Taak: De uitvoering en het resultaat van coroutines worden bepaald door de taken. U kunt meerdere taken toewijzen met behulp van een asynchrone bibliotheek en de taken asynchroon uitvoeren run.
Toekomst: Het fungeert als een toekomstige opslag waar het resultaat van coroutines na voltooiing wordt opgeslagen. Dit is handig wanneer een coroutine moet wachten op het resultaat van andere coroutine.
Hoe u de bovenstaande concepten van asyncio-bibliotheek kunt implementeren, wordt in deze zelfstudie getoond aan de hand van enkele eenvoudige voorbeelden.
Voorbeeld-1: Maak een enkele coroutine met een enkele taak
Maak een bestand met de naam async1.py en voeg de volgende code toe:. asyncio-bibliotheek wordt geïmporteerd om de functies van deze bibliotheek te gebruiken. toevoegen functie wordt gedeclareerd om de som van een bepaald bereik van getallen te berekenen. Het nummerbereik van 1 tot 101 wordt toegewezen door de taak met een vertraging van één seconde. De gebeurtenislus wordt verklaard dat deze wordt uitgevoerd totdat alle taken van de hoofdmethode zijn voltooid. Na het berekenen van de waarde wacht de functie één seconde en drukt het resultaat af.
asynchrone importerenasync def add(start,end,wait):
#Initialiseer somvariabele
som = 0
#Bereken de som van alle getallen
voor n in bereik (begin, einde):
som += n
#Wacht op toegewezen seconden
wachten asyncio.slapen (wacht)
#Print het resultaat
print(f'Sum van start tot end is sum')
asynchrone def main():
#Een enkele taak toewijzen
taak = lus.create_task(add(1,101,1))
#Voer de taak asynchroon uit
wachten asyncio.wacht ([taak])
if __name__ == '__main__':
#Declare event loop
lus = asynchrone.get_event_loop()
#Voer de code uit tot het voltooien van alle taken
lus.run_until_complete(main())
#Sluit de cirkel
lus.dichtbij()
Uitgang:
$ python3 async1.pyDe uitvoer toont de som van 1 tot 101, wat 5050 . is.
Voorbeeld-2: Meerdere coroutines maken
Het gebruik van de asyncio-bibliotheek wordt gewist wanneer u meerdere coroutines tegelijkertijd uitvoert. Maak een nieuw bestand met de naam async2.py en voeg de volgende code toe:. Er worden drie taken gegenereerd met drie verschillende bereiken en wachtwaarden in hoofd() methode. De eerste taak berekent de som van 5 tot 500000 door 3 seconden te wachten, de tweede taak berekent de som van 2 tot 300000 door 2 seconden te wachten en de derde taak berekent de som van 10 tot 1000 door 1 seconden te wachten. De taak met een lage wachtwaarde wordt eerst voltooid en de taak met een hoge wachtwaarde wordt uiteindelijk voltooid.
asynchrone importerenasync def add(start,end,wait):
#Initialiseer somvariabele
som = 0
#Bereken de som van alle getallen
voor n in bereik (begin, einde):
som += n
#Wacht op toegewezen seconden
wachten asyncio.slapen (wacht)
#Print het resultaat
print(f'Sum van start tot end is sum')
asynchrone def main():
#Toewijzen eerste taak
taak1=lus.create_task(add(5,50000,3))
#Tweede taak toewijzen
taak2=lus.create_task(add(2,300000,2))
#Derde taak toewijzen
taak3=lus.create_task(add(10,1000,1))
#Voer de taken asynchroon uit
wachten asyncio.wacht([taak1,taak2,taak3])
if __name__ == '__main__':
#Declare event loop
lus = asynchrone.get_event_loop()
#Voer de code uit tot het voltooien van alle taken
lus.run_until_complete(main())
#Sluit de cirkel
lus.dichtbij()
Uitgang:
$ python3 async1.pyDe output laat zien dat taak3 als eerste is voltooid omdat de wachttijd van deze taak slechts 1 seconde was en taak1 als laatste is voltooid omdat de wachttijd van deze taak 3 seconden was.
Voorbeeld-3: coroutines met toekomst
Dit voorbeeld toont het gebruik van toekomstig object van asyncio-bibliotheek. Maak een nieuw bestand met de naam async3.py en voeg de volgende code toe:. In dit voorbeeld zijn twee taken toegewezen voor de toekomst. toon bericht functie wordt hier gedeclareerd om het bericht af te drukken voordat de coroutine wordt uitgevoerd en na het voltooien van de uitvoering. De eerste taak wacht 2 seconden en wordt als laatste voltooid. De tweede taak wacht 1 seconde en wordt als eerste voltooid.
asynchrone importerenasync def show_message (nummer, wacht):
#Print het bericht
print(f'Taak nummer loopt')
#Wacht op toegewezen seconden
wachten asyncio.slapen (wacht)
print(f'Taak nummer is voltooid')
async def stop_after (wanneer):
wachten asyncio.slapen (wanneer)
lus.hou op()
asynchrone def main():
#Toewijzen eerste taak
taak1=asyncio.zorgen_toekomst(show_message(1,2))
print('Schema 1')
#Tweede taak toewijzen
taak2=asynchroon.zorgen_toekomst(show_message(2,1))
print('Schema 2')
#Voer de taken asynchroon uit
wachten asyncio.wacht([taak1,taak2])
if __name__ == '__main__':
#Declare event loop
lus = asynchrone.get_event_loop()
#Voer de code van de hoofdmethode uit totdat u alle taken hebt voltooid
lus.run_until_complete(main())
Uitgang:
$ python3 async3.pyIn de uitvoer wordt weergegeven dat taak1 als eerste is gestart en als laatste is voltooid, en taak2 later wordt gestart maar eerst wordt voltooid voor een korte wachttijd.
Conclusie
Het basisconcept van asynchrone programmering met behulp van asyncio-bibliotheek van python wordt hier uitgelegd:. Hoop, je zult in staat zijn om multi-threaded code in python te schrijven na het oefenen van de voorbeelden van deze tutorial.
