Oppretting og kjøring av korutiner

For å begynne med asynkron programmering i Python, er det viktig å forstå korutiner. En korutine er en spesiell funksjon definert med async def. Korutiner gjør det mulig å pause og gjenoppta kjøring, slik at du kan håndtere oppgaver som å vente på inn-/utdataoperasjoner – som filavlesning, nettverksforespørsler eller databasespørringer – uten å blokkere hele programmet. Dette betyr at mens én oppgave venter på data, kan andre oppgaver fortsette å kjøre, noe som gir bedre effektivitet og respons.

For å kjøre en korutine bruker du asyncio.run, som starter en hendelsesløkke, kjører korutinen din, og lukker løkken når den er ferdig. Dette er standardmetoden for å starte asynkron kode i moderne Python.

Hvis du ønsker å kjøre flere korutiner samtidig, kan du bruke asyncio.gather for å planlegge dem parallelt. Dette lar programmet ditt starte flere oppgaver og vente til alle er ferdige, noe som gir bedre utnyttelse av tiden, spesielt når du venter på trege operasjoner som I/O.

Følgende kode demonstrerer disse konseptene.

import asyncio

async def greet(name, delay):
    await asyncio.sleep(delay)
    print(f"Hello, {name}!")

async def main():
    # Schedule two coroutines to run concurrently
    await asyncio.gather(
        greet("Alice", 2),
        greet("Bob", 1)
    )

asyncio.run(main())

Forventet resultat:

Hello, Bob!
Hello, Alice!

Bobs hilsen vises først fordi den bruker en kortere forsinkelse (1 sekund) enn Alices (2 sekunder).

Korutinen greet opprettes med async def, noe som gjør det mulig å pause utførelsen med await asyncio.sleep(delay) før en hilsen skrives ut. Korutinen main planlegger to forekomster av greet – én for "Alice" med 2 sekunders forsinkelse, og én for "Bob" med 1 sekunds forsinkelse – ved å bruke asyncio.gather. Dette betyr at begge hilsningene håndteres samtidig, slik at programmet ikke venter på at én skal bli ferdig før den andre starter. Til slutt starter asyncio.run(main()) hendelsesløkken, kjører korutinen main, og sørger for at alt ryddes opp etterpå. Denne tilnærmingen lar deg håndtere flere oppgaver som innebærer venting (som nettverksforespørsler eller tidsforsinkelser) samtidig, noe som gjør programmet ditt mer effektivt og responsivt.