0Pricing
C++ Academy · Lezione

Basi di std::async e std::future

Esegua attività in modo asincrono e ne recuperi i risultati tramite std::future

Basi di std::async e std::future è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Task asincroni

std::async esegue una funzione in modo asincrono e restituisce un std::future che fornisce il risultato. È un'alternativa di livello più elevato alla gestione manuale dei thread.

Utilizzo di base

Passi un callable e gli argomenti. std::async restituisce un std::future<Result>.

#include <future>

int compute() { return 42; }

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

Politiche di avvio

Il primo argomento controlla quando viene eseguito il task:

  • std::launch::async — avvia immediatamente un nuovo thread
  • std::launch::deferred — esegue il task in modo sincrono durante get()
  • Predefinita (nessuna policy) — la scelta spetta all'implementazione
auto f = std::async(std::launch::async, compute);

Metodi di std::future

Operazioni comuni:

  • get() — blocca fino al completamento e restituisce il risultato, una sola volta
  • wait() — blocca, ma non restituisce il risultato
  • wait_for(d) / wait_until(t) — attese temporizzate
  • valid() — indica se questo future è stato configurato

Propagazione delle eccezioni

Se il task asincrono genera un'eccezione, questa viene memorizzata nel future e rilanciata da get().

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

Restituire più valori

Racchiuda il risultato in una tupla, una struct o un container.

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

Più task in parallelo

Avvii diversi task asincroni e attenda che siano terminati tutti.

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: future manuale

Per i modelli produttore-consumatore in cui il consumer necessita di un future, mentre il produttore si trova in un altro thread, utilizzi 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

Raggruppa un callable e un future. È utile quando il task viene invocato altrove, ad esempio in un thread pool.

shared_future

Un std::future può essere letto una sola volta. std::shared_future consente più letture, risultando utile per distribuire un risultato.

Comportamento del distruttore

Il distruttore di un future restituito da std::async con la policy predefinita può bloccarsi fino al completamento del task. Ne tenga conto nei task di lunga durata.

Oltre std::async

Per un'asincronia adatta all'uso in produzione, consideri librerie come Boost.Asio, Folly oppure gli executor e le coroutine di C++20/23. std::async è un punto di partenza.

Verifica rapida

Che cosa comporta chiamare .get() su un std::future?

Riepilogo

std::async esegue una funzione in modo asincrono; il std::future restituito fornisce il risultato e propaga le eccezioni. Utilizzi le policy di avvio per controllare l'esecuzione. Per i modelli più complessi, utilizzi std::promise e std::packaged_task.

Domande Frequenti

La lezione «Basi di std::async e std::future» è gratuita?

Sì — il testo completo di «Basi di std::async e std::future» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Basi di std::async e std::future»?

Esegua attività in modo asincrono e ne recuperi i risultati tramite std::future Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Basi di std::async e std::future»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. std::thread: join e detach
  2. std::mutex, lock_guard e unique_lock
  3. Variabili di condizione e pattern worker
  4. Basi di std::async e std::future
← Torna a C++ Academy