C++ Academy · Lekcja

Podstawy std::async i std::future

Uruchamiaj zadania asynchronicznie i pobieraj ich wyniki za pośrednictwem std::future

Podstawy std::async i std::future to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Zadania asynchroniczne

std::async uruchamia funkcję asynchronicznie i zwraca obiekt std::future, który dostarcza wynik. Jest to rozwiązanie wyższego poziomu niż ręczne zarządzanie wątkami.

Podstawowe użycie

Należy przekazać obiekt wywoływalny i argumenty. std::async zwraca obiekt std::future<Result>.

#include <future>

int compute() { return 42; }

std::future<int> f = std::async(compute);
int result = f.get();   // blocks until done

Zasady uruchamiania

Pierwszy argument określa, kiedy zostanie uruchomione zadanie:

std::launch::async — natychmiast uruchamia nowy wątek
std::launch::deferred — wykonuje zadanie synchronicznie podczas wywołania get()
Domyślnie, bez określenia zasady — decyzję podejmuje implementacja

auto f = std::async(std::launch::async, compute);

Metody std::future

Typowe operacje:

get() — blokuje wykonanie do zakończenia i zwraca wynik (tylko raz)
wait() — blokuje wykonanie, ale nie zwraca wyniku
wait_for(d) / wait_until(t) — oczekiwanie z limitem czasu
valid() — czy ten obiekt future został skonfigurowany?

Przekazywanie wyjątków

Jeśli zadanie asynchroniczne zgłosi wyjątek, zostanie on zapisany w obiekcie future i ponownie zgłoszony podczas wywołania get().

auto f = std::async([] { throw std::runtime_error("oops"); });
try {
    f.get();
} catch (const std::exception& e) {
    std::cout << e.what();
}

Zwracanie wielu wartości

Należy opakować wynik w krotkę, strukturę albo kontener.

auto f = std::async([] {
    return std::make_pair(42, std::string("hello"));
});
auto [n, s] = f.get();

Wiele zadań równolegle

Należy uruchomić kilka zadań asynchronicznych i zaczekać na zakończenie wszystkich.

auto a = std::async(work_a);
auto b = std::async(work_b);
auto c = std::async(work_c);

std::cout << a.get() + b.get() + c.get();

std::promise: ręczny future

W przypadku wzorców producent–konsument, w których konsument potrzebuje obiektu future, a producent działa w innym wątku, należy użyć std::promise.

std::promise<int> p;
std::future<int> f = p.get_future();

std::thread t([&p] { p.set_value(42); });
std::cout << f.get();
t.join();

std::packaged_task

Łączy obiekt wywoływalny z obiektem future. Jest przydatny, gdy zadanie jest wywoływane w innym miejscu, na przykład w puli wątków.

shared_future

Obiekt std::future można odczytać tylko raz. std::shared_future umożliwia wielu odbiorcom odczyt — jest przydatny do rozgłaszania wyniku.

Zachowanie destruktora

Destruktor obiektu future zwróconego przez std::async z domyślną zasadą może blokować wykonanie do czasu zakończenia zadania. Należy o tym pamiętać w przypadku długo działających zadań.

Poza std::async

W przypadku asynchroniczności wymaganej w środowisku produkcyjnym warto rozważyć biblioteki takie jak Boost.Asio i Folly albo mechanizmy executorów i korutyn z C++20/23. std::async to rozwiązanie na początek.

Szybkie sprawdzenie

Co robi wywołanie .get() na obiekcie std::future?

Podsumowanie

std::async uruchamia funkcję asynchronicznie, a zwrócony obiekt std::future dostarcza wynik i przekazuje wyjątki. Zasady uruchamiania pozwalają kontrolować wykonanie. W przypadku złożonych wzorców należy użyć std::promise i std::packaged_task.

Często zadawane pytania

Czy lekcja „Podstawy std::async i std::future” jest bezpłatna?

Tak — pełny tekst „Podstawy std::async i std::future” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Podstawy std::async i std::future”?

Uruchamiaj zadania asynchronicznie i pobieraj ich wyniki za pośrednictwem std::future Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Podstawy std::async i std::future”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy