Korutyny Vs Wątki

W przypadku wątków to system operacyjny (lub środowisko), przełącza sterowanie między wątkami. Natomiast w przypadku korutyn to programista i język programowania decydują, kiedy przełączać sterowanie. Korutyny współpracują, wielozadaniowo, zawieszając i wznawiając się w ustalonych przez programistę punktach.

Wątki umożliwiają programowi podzielenie się na dwa lub więcej jednocześnie (lub pseudojednocześnie) uruchomionych zadań. Są one implementowane przez system operacyjny i mają własny stos i przestrzeń pamięci. Mogą działać niezależnie od siebie i mogą wchodzić w interakcję ze współdzielonymi zasobami poprzez mechanizmy synchronizacji, takie jak blokady i semafory.

Z drugiej strony korutyny są konstrukcją na poziomie języka służącą współbieżności. Są podobne do podprogramów, ale w przeciwieństwie do podprogramów, korutyna może zapisać swój stan, a następnie wznowić od miejsca, w którym została przerwana.

Korutyna pozwala jednej „oddać” kontrolę innej korutynie i wznowić ją później od miejsca, w którym została przerwana, w przeciwieństwie do wątków, które zwykle są wykonywane w sposób ciągły aż do zakończenia lub zablokowania przez jakieś zdarzenie zewnętrzne.

Podsumowując, wątki są funkcją na poziomie systemu operacyjnego, a współprogramy są funkcją na poziomie języka proramowania służące do kontrolowanego współbieżnego wykonywania operacji. Korutyny to konstrukcja programistyczna, którą można traktować jako lekką wersję wątków.

Korutyna jako funkcja przetwarzająca dane (filtrująca napisy posiadajace określony prefix):

# Python3 program for demonstrating
# coroutine execution

def print_name(prefix):
    print("Searching prefix: {}".format(prefix))
    while True:
        name = (yield)
        if prefix in name:
            print(name)

# calling coroutine, nothing will happen
corou = print_name("Dear")

# This will start execution of coroutine and
# Prints first line "Searching prefix..."
# and advance execution to the first yield expression
corou.__next__()

# sending inputs
corou.send("")
corou.send("Student")
corou.send("Dear Student")
corou.send("Dear St")

Searching prefix: Dear
Dear Student
Dear St

Korutyna może działać w nieskończoność, do zamknięcia korutyny używana jest metoda Close(). Gdy korutyna jest zamknięta, generuje wyjątek GeneratorExit. Jeżeli po zamknięciu współprogramu spróbujemy wysłać wartości, zgłosi to wyjątek StopIteration. Poniżej znajduje się prosty przykład:

# Python3 program for demonstrating
# closing a coroutine
def print_name(prefix):
    print("Searching prefix:{}".format(prefix))
    try :
        while True:
                name = (yield)
                if prefix in name:
                    print(name)
    except GeneratorExit:
            print("Closing coroutine!!")

corou = print_name("Dear")
corou.__next__()
corou.send("Dear Student")
corou.close()
corou.send("Dear Student")

Searching prefix:Dear
Dear Student
Closing coroutine!!

---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

Cell In [117], line 17
     15 corou.send("Dear Student")
     16 corou.close()
---> 17 corou.send("Dear Student")


StopIteration:

Korutyna jako przykład przetwarzania producent-konsument:

# Python3 program for demonstrating
# coroutine chaining

def producer(sentence, next_coroutine):
    '''
    Dzielimy zdanie i wysyłamy dalej
    '''
    tokens = sentence.split(" ")
    for token in tokens:
        next_coroutine.send(token)
    next_coroutine.close()

def pattern_filter(next_coroutine=None):
    '''
    Filtrujemy szukając słow na a
    '''
    print("Fitrowanie")
    try:
        while True:
            token = (yield)
            if token.startswith('a') or token.startswith('A'):
                next_coroutine.send(token)
    except GeneratorExit:
        print("Done with filtering!!")
        next_coroutine.close()

def consumer():
    '''
    Wypisz filtrowane słowa
    '''
    print("I'm sink, i'll print tokens")
    try:
        while True:
            token = (yield)
            print(token)
    except GeneratorExit:
        print("Done with printing!")

pt = consumer()
pt.__next__()
pf = pattern_filter(next_coroutine = pt)
pf.__next__()

sentence = "Ala ma kota Afika, ale to fajne."
producer(sentence, pf)

I'm sink, i'll print tokens
Fitrowanie
Ala
Afika,
ale
Done with filtering!!
Done with printing!

Korutyny i async

Korutyny zapewniają nam łatwy sposób programowania synchronicznego i asynchronicznego, ponieważ umożliwiają zawieszenie i wznowienie wykonywania później w pewnym momencie w przyszłości, co najlepiej nadaje się do wykonywania operacji nieblokujących w przypadku wielowątkowości.

Korutyny mogą być implementowane za pomocą async def statement. Preferowanym sposobem pisania aplikacji asyncio są współprogramy zadeklarowane ze składnią async/await. Mówimy, że obiekt jest obiektem awaitable, jeśli można go użyć w wyrażeniu await. Istnieją trzy główne typy obiektów odpowiadających na await: korutyny, zadania (tasks) i future.

Na przykład następujący fragment kodu (wymaga Pythona 3.7 lub nowszego) wypisuje „hello”, czeka 1 sekundę, a następnie wypisuje „world”:

import asyncio

async def main():
    print('hello')
    await asyncio.sleep(1)
    print('world')

await main()

hello
world

import asyncio
import time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    print(f"started at {time.strftime('%X')}")

    await say_after(1, 'hello')
    await say_after(2, 'world')

    print(f"finished at {time.strftime('%X')}")

await main()

started at 14:22:44
hello
world
finished at 14:22:47

Korutyna bez await nie zostanie wykonana

import asyncio

async def nested():
    return 42

async def main():
    # Nothing happens if we just call "nested()".
    # A coroutine object is created but not awaited,
    # so it *won't run at all*.
    nested()

    # Let's do it differently now and await it:
    print(await nested())  # will print "42".

await main()

42

/tmp/ipykernel_52663/1163459027.py:10: RuntimeWarning: coroutine 'nested' was never awaited
  nested()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

Funkcja asyncio.create_task() pozwala nam jednocześnie uruchamianiać korutyny jako zadania asyncio.

Zmodyfikujmy powyższy przykład i uruchommy jednocześnie dwie współprogramy say_after:

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    task1 = asyncio.create_task(
        say_after(1, 'hello'))

    task2 = asyncio.create_task(
        say_after(2, 'world'))

    print(f"started at {time.strftime('%X')}")

    # Wait until both tasks are completed (should take
    # around 2 seconds.)
    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")

await main()

started at 14:44:48
hello
world
finished at 14:44:50

Jak widzimy wykonanie zadań jest w tym wypadku o wiele szybsze.

To nieblokujące zachowanie jest niezbędne w programowaniu asynchronicznym i jest zarządzane przez pętlę zdarzeń, taką jak ta udostępniana przez moduł asyncio. Pętla zdarzeń uruchamia zadania asynchroniczne i wywołania zwrotne, zarządza komunikacją między nimi i obsługuje zdarzenia we/wy.

import asyncio

async def task(name, delay):
    print(f"Task {name} starting with delay {delay}")
    await asyncio.sleep(delay)
    print(f"Task {name} completed after {delay} seconds")

async def main():
    # Schedule multiple tasks concurrently
    await asyncio.gather(
        task("A", 2),  # Task A will take 2 seconds to complete
        task("B", 3),  # Task B will take 3 seconds to complete
        task("C", 1)   # Task C will take 1 second to complete
    )
    print("All tasks completed")

# Run the main coroutine
await main()

Task A starting with delay 2
Task B starting with delay 3
Task C starting with delay 1
Task C completed after 1 seconds
Task A completed after 2 seconds
Task B completed after 3 seconds
All tasks completed

W głównej korutynie asyncio.gather służy do jednoczesnego uruchamiania wielu instancji zadania. To pokazuje wielozadaniowość kooperacyjną, w której Zadanie C zakończy się przed Zadaniem A i Zadaniem B, mimo że zostanie rozpoczęte po nich.

Zastosowanie

Programowanie asynchroniczne za pomocą korutyn jest szczególnie skuteczne w przypadku działań związanych z we/wy i charakteryzujących się dużymi opóźnieniami. W przeciwieństwie do tradycyjnego wątków, programowanie asynchroniczne za pomocą korutyn pozwala na jednoczesne zarządzanie wieloma zadaniami w jednym wątku, zmniejszając obciążenie i złożoność. Jest to szczególnie przydatne w scenariuszach takich jak obsługa wielu połączeń sieciowych lub wykonywanie operacji wymagających oczekiwania na zasoby zewnętrzne.

Żeby uruchomić poniższy przykład potrzebujesz modułu aiohttp spoza Jupytera, uruchom więc go lokalnie na komputerze

import asyncio
import aiohttp

async def fetch(url, session):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        "http://google.com",
        "http://yahoo.com",
        "http://facebook.com",
    ]

    async with aiohttp.ClientSession() as session:
        tasks = [fetch(url, session) for url in urls]
        responses = await asyncio.gather(*tasks)

        for response in responses:
            print(response[:100])  # Print first 100 characters of each response

def run_asyncio_coroutine():
    try:
        # Get the current event loop, but don't close it afterwards
        loop = asyncio.get_event_loop()
    except RuntimeError as e:
        # If no current event loop, create a new one
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)

    # Run the coroutine
    loop.run_until_complete(main())

# Execute the function
await main()

/usr/lib/python3.9/genericpath.py:77: RuntimeWarning: coroutine 'main' was never awaited
  m = tuple(map(os.fspath, m))
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

Cell In [43], line 34
     31     loop.run_until_complete(main())
     33 # Execute the function
---> 34 await main()


Cell In [43], line 14, in main()
      7 async def main():
      8     urls = [
      9         "http://google.com",
     10         "http://yahoo.com",
     11         "http://facebook.com",
     12     ]
---> 14     async with aiohttp.ClientSession() as session:
     15         tasks = [fetch(url, session) for url in urls]
     16         responses = await asyncio.gather(*tasks)


NameError: name 'aiohttp' is not defined