Oprettelse og kørsel af koroutiner

For at begynde at arbejde med asynkron programmering i Python, skal du forstå coroutines. En coroutine er en speciel funktion defineret med async def. Coroutines gør det muligt at pause og genoptage eksekvering, hvilket gør det muligt at håndtere opgaver som at vente på input/output-operationer – såsom fil-læsning, netværksforespørgsler eller databaseforespørgsler – uden at blokere hele programmet. Dette betyder, at mens én opgave venter på data, kan andre opgaver fortsætte med at køre, hvilket forbedrer effektivitet og reaktionsevne.

For at køre en coroutine bruger du asyncio.run, som starter en event loop, kører din coroutine og lukker loopen, når den er færdig. Dette er den standardmetode til at starte asynkron kode i moderne Python.

Hvis du ønsker at køre mere end én coroutine på samme tid, kan du bruge asyncio.gather til at planlægge dem samtidigt. Dette gør det muligt for dit program at starte flere opgaver og vente på, at alle bliver færdige, hvilket udnytter tiden bedre, især når der ventes på langsomme operationer som I/O.

Følgende kode demonstrerer disse koncepter.

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 bruger en kortere forsinkelse (1 sekund) end Alices (2 sekunder).

Coroutine'en greet oprettes med async def, hvilket gør det muligt at pause udførelsen med await asyncio.sleep(delay) før der udskrives en hilsen. Coroutine'en main planlægger to forekomster af greet – én for "Alice" med 2 sekunders forsinkelse og én for "Bob" med 1 sekunds forsinkelse – ved hjælp af asyncio.gather. Dette betyder, at begge hilsner håndteres samtidigt, så programmet ikke venter på, at den ene er færdig, før den anden starter. Til sidst starter asyncio.run(main()) event loopet, kører coroutine'en main og sørger for, at alt ryddes op bagefter. Denne tilgang gør det muligt at håndtere flere opgaver, der involverer ventetid (som netværksanmodninger eller tidsforsinkelser), på samme tid, hvilket gør dit program mere effektivt og responsivt.