Programowanie asynchroniczne to paradygmat programowania, który umożliwia jednoczesne i niezależne wykonywanie wielu procesów bez czekania na zakończenie jednego przed przejściem do następnego. W tym wpisie na blogu przyjrzymy się, czym jest programowanie asynchroniczne i jak go używać w pythonie.

Co to jest programowanie asynchroniczne?

W programowaniu synchronicznym komputer wykonuje instrukcje w kolejności sekwencyjnej, blokując wykonanie do momentu zakończenia zadania przed przejściem do następnego.
Z drugiej strony programowanie asynchroniczne umożliwia programowi rozpoczęcie jednej operacji, a następnie przejście do innej bez zatrzymywania wykonywania, dopóki pierwotne zadanie nie zostanie zakończone.

Programowanie asynchroniczne jest szczególnie przydatne w okolicznościach, w których procesy, takie jak operacje we/wy sieci lub operacje na bazie danych, mogą zająć dużo czasu. Programowanie asynchroniczne może pomóc zwiększyć wydajność i szybkość reakcji aplikacji, umożliwiając programowi przejście do innych działań podczas oczekiwania na zakończenie powolnej operacji.

W zależności od używanego języka programowania i struktury, programowanie asynchroniczne można realizować przy użyciu różnych strategii, takich jak wywołania zwrotne, obietnice lub słowa kluczowe async/await.

Różnice między programowaniem asynchronicznym a przetwarzaniem wielokrotnym

Główna różnica między programowaniem asynchronicznym a przetwarzaniem wieloprocesorowym polega na tym, że programowanie asynchroniczne umożliwia wykonywanie operacji nieblokujących w ramach jednego wątku, podczas gdy przetwarzanie wieloprocesowe wykorzystuje wiele rdzeni lub procesów do wykonywania pracy jednocześnie.

Różnice między programowaniem asynchronicznym a wątkowaniem

Główna różnica między programowaniem asynchronicznym a wątkowaniem polega na tym, że programowanie asynchroniczne umożliwia wykonywanie operacji bez blokowania przy użyciu pojedynczego wątku, podczas gdy wątkowanie wykorzystuje wiele wątków do wykonywania wielu zadań równolegle.

Aby uzyskać więcej informacji o różnicach: Treading vs Multiprocessing vs Programowanie asynchroniczne

Jak korzystać z Asyncio?

Najpierw stwórzmy prosty program, który zaczyna wykonywać zadania na raz i je kończy.

import time
import asyncio

def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

main()

# OUTPUT
# Job A started
# Job Adone
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

Tworzenie i uruchamianie Coroutines

Współprogram to rodzaj funkcji, którą można przerywać i wznawiać w różnych momentach wykonywania. Innymi słowy, współprogram umożliwia pisanie kodu, który można przerwać, zrobić coś innego, a następnie wznowić od miejsca, w którym zostało przerwane.

Aby utworzyć współprogramy, musimy użyć asyncsłowa kluczowego przed defsłowem kluczowym. Wywołanie współprogramu nie wywołuje funkcji, którą chcemy uruchomić. Tworzy zadanie.

import time
import asyncio

async def do_job(s):
  ...

async def main():
  ...

main()

asyncio.run(main())

jeśli uruchomisz ten kod, prawdopodobnie pojawi się błąd podobny do tego:

RuntimeWarning: coroutine '...' was never awaited

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        await do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job A done
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

await asyncio.sleep(1)

tasks = [asyncio.create_task(do_job(item)) for item in todo]
done, pending = await asyncio.wait(tasks)

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    
    tasks = [asyncio.create_task(do_job(item)) for item in todo]
    done, pending = await asyncio.wait(tasks)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job B started
# Job C started
# Job A done
# Job B done
# Job C done
# Took: 1.009 seconds

Możesz zobaczyć wideo, aby uzyskać więcej informacji na temat programowania asynchronicznego w Pythonie. ( Wprowadzenie do Pythona asynchronicznego | Pisanie robota sieciowego )