std::async

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate. La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui. Click here for the English version of this page

• Se la bandiera async è impostato (cioè policy & std::launch::async != 0), poi async genera un nuovo thread di esecuzione come per std::thread(f, args...), salvo che, se la funzione restituisce un valore f o genera un'eccezione, viene memorizzato nello stato condiviso accessibile attraverso la std::future che async restituisce al chiamante.

  Original:

  If the async flag is set (i.e. policy & std::launch::async != 0), then async spawns a new thread of execution as if by std::thread(f, args...), except that if the function f returns a value or throws an exception, it is stored in the shared state accessible through the std::future that async returns to the caller.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Se la differita bandiera' è impostato (cioè policy & std::launch::deferred != 0), poi convertiti async args... allo stesso modo dal costruttore std::thread, ma non genera un nuovo thread di esecuzione. Invece, valutazione pigro viene eseguita: la prima chiamata a un non-temporizzato attendere funzione sul std::future che async restituito al chiamante causerà f(args...) da eseguire nel thread corrente. Tutti gli ulteriori accessi al std::future stesso restituirà immediatamente il risultato.

  Original:

  If the deferred flag is set (i.e. policy & std::launch::deferred != 0), then async converts args... the same way as by std::thread constructor, but does not spawn a new thread of execution. Instead, lazy evaluation is performed: the first call to a non-timed wait function on the std::future that async returned to the caller will cause f(args...) to be executed in the current thread. All further accesses to the same std::future will return the result immediately.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Se entrambe le bandierine std::launch::async e std::launch::deferred si trovano in policy, spetta alla realizzazione se eseguire l'esecuzione asincrona o valutazione pigra.

  Original:

  If both the std::launch::async and std::launch::deferred flags are set in policy, it is up to the implementation whether to perform asynchronous execution or lazy evaluation.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[modifica] Parametri

[modifica] Valore di ritorno

[modifica] Eccezioni

[modifica] Note

[modifica] Esempio

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <future>
 
template <typename RAIter>
int parallel_sum(RAIter beg, RAIter end)
{
    typename RAIter::difference_type len = end-beg;
    if(len < 1000)
        return std::accumulate(beg, end, 0);
 
    RAIter mid = beg + len/2;
    auto handle = std::async(std::launch::async,
                              parallel_sum<RAIter>, mid, end);
    int sum = parallel_sum(beg, mid);
    return sum + handle.get();
}
 
int main()
{
    std::vector<int> v(10000, 1);
    std::cout << "The sum is " << parallel_sum(v.begin(), v.end()) << '\n';
}

The sum is 10000