Przejdź do głównej treści
Polski— Wybierz język
Menu

Kiedy używać async, a kiedy sync

Lekcja 3 z 12 Zaktualizowano 30 lipca 2026 Zaawansowany
Na tej stronie
  1. Wybór nie zawsze jest oczywisty
  2. Kiedy sync wystarczy
  3. Kiedy async jest konieczny
  4. Pułapka przedwczesnego async
  5. Drzewo decyzyjne
  6. Kluczowe wnioski

Wybór nie zawsze jest oczywisty

Async nie jest automatycznie lepszy od sync. Każde podejście ma konteksty, w których sprawdza się najlepiej, a wybór niewłaściwego może skomplikować Twój kod bez żadnej korzyści wydajnościowej. Ta lekcja pomoże Ci zdecydować, które podejście przyjąć w Twojej sytuacji.

Kiedy sync wystarczy

Klient sync pozostaje właściwym wyborem częściej, niż mogłoby się wydawać, a powód jest zawsze ten sam: gdy równoległość nic nie wnosi, jej złożoność staje się czystym kosztem. Jednorazowy test lub skrypt eksploracyjny wysyłający kilka żądań nic nie zyska dzięki async – na pierwszym miejscu stoi prostota kodu, a ten skrypt i tak przeczytasz za sześć miesięcy. Sekwencyjny potok, w którym każde żądanie zależy od wyniku poprzedniego, i tak nie pozwala na żadną paralelizację: async dodałby tylko składnię, nie zmieniając czasu wykonania nawet o sekundę. Ta sama logika dotyczy tradycyjnej aplikacji Django: jeśli Twój stos technologiczny nie jest async, dodanie asyncio wyłącznie do wywołań API stworzy granicę sync/async, którą trudno będzie utrzymać. Wreszcie, w fazie prototypowania, gdy testujesz prompt lub walidujesz koncepcję, kod sync czyta się i pisze szybciej – dokładnie tego oczekujesz od prototypu.

# Sync — idealny do sekwencyjnego potoku
from openai import OpenAI

client = OpenAI(api_key=os.getenv("XAI_API_KEY"), base_url="https://api.x.ai/v1")

# Krok 1: analiza tekstu
analysis = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Analyze this text: {text}"}]
).choices[0].message.content

# Krok 2: generowanie podsumowania na podstawie analizy
summary = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content

W tym przykładzie krok 2 zależy od wyniku kroku 1. Async nie przynosi żadnych korzyści.

Kiedy async jest konieczny

Async staje się niezbędny, gdy opóźnienia sieciowe dominują nad czasem wykonania, a żądania są od siebie niezależne. Klasycznym przypadkiem jest przetwarzanie wsadowe: dziesiątki lub setki żądań bez zależności między nimi, gdzie zysk jest proporcjonalny do wolumenu – sto żądań trwających po dwie sekundy zajmie trzy minuty sekwencyjnie, a około dziesięciu sekund przy kontrolowanej równoległości. Drugi przypadek to nie wybór, lecz wymóg: w aplikacji opartej na FastAPI lub Starlette framework jest już async, więc użycie klienta sync zablokuje pętlę zdarzeń – każde wywołanie Grok zamrozi wszystkie inne żądania do Twojego serwera. Istnieją też architektury naturalnie współbieżne: chatbot odpytujący równolegle Grok, bazę danych i zewnętrzne API, aby złożyć odpowiedź, lub system monitoringu obserwujący jednocześnie kilka strumieni – async jest tu po prostu naturalnym dopasowaniem do problemu.

# Async — przetwarzanie 50 pytań równolegle
async def batch_process(questions: list[str]) -> list[str]:
    sem = asyncio.Semaphore(5)

    async def ask(q: str) -> str:
        async with sem:
            resp = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": q}]
            )
            return resp.choices[0].message.content

    return await asyncio.gather(*[ask(q) for q in questions])

Przy 50 pytaniach i semaforze o wartości 5 przetwarzasz 5 żądań równolegle zamiast jednego. Jeśli każde żądanie trwa 8 sekund, całkowity czas spada z 400 sekund do około 80 sekund.

Pułapka przedwczesnego async

Źle zaprojektowany kod async jest gorszy niż dobrze napisany kod sync. Oto typowe błędy:

Blokowanie pętli zdarzeń

# ŹLE: wywołanie sync w funkcji async
async def bad_example():
    response = requests.get("https://api.example.com")  # blokuje wszystko
    return response.json()

Biblioteka requests działa w trybie sync. Wywołanie jej w korutynie blokuje pętlę zdarzeń i niweczy wszelkie korzyści z async. Zamiast tego użyj httpx lub aiohttp.

Niepotrzebna złożoność

# ŹLE: async dla pojedynczego żądania
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Odpowiednik sync, prostszy
def simple():
    response = client.chat.completions.create(...)
    return response

Jeśli masz do wysłania tylko jedno żądanie, async dodaje złożoność bez żadnych korzyści.

Drzewo decyzyjne

Aby wybrać między sync a async, zadaj sobie kolejno następujące pytania:

  1. Ile żądań API wysyłasz? Jeśli jedno lub kilka sekwencyjnie, pozostań przy sync.
  2. Czy żądania są od siebie niezależne? Jeśli każde żądanie zależy od poprzedniego, pozostań przy sync.
  3. Czy Twój framework jest async? Jeśli tak (FastAPI, Starlette, aiohttp), użyj async, aby uniknąć blokowania pętli zdarzeń.
  4. Czy całkowity czas przetwarzania jest problemem? Jeśli przetwarzasz wsady, a czas w trybie sync jest nieakceptowalny, przełącz się na async.

Kluczowe wnioski

  • Sync sprawdza się w prostych skryptach, sekwencyjnych potokach i prototypowaniu
  • Async jest konieczny przy przetwarzaniu wsadowym, w frameworkach async i przy żądaniach równoległych
  • Nigdy nie używaj bibliotek sync (requests) w kodzie async
  • Złożoność wprowadzana przez async musi być uzasadniona mierzalnymi korzyściami
  • Zacznij od sync, przejdź na async dopiero, gdy potrzeba zostanie potwierdzona