std::async

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

• Si le' async drapeau est positionné (c.-à-policy & std::launch::async != 0), puis async génère un nouveau thread d'exécution comme par std::thread(f, args...), sauf que si la fonction renvoie une valeur f ou lève une exception, elle est stockée dans l'état partagé accessible à travers le std::future que async retourne à l'appelant .

  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.

• Si le drapeau' différé est activé (c'est à dire policy & std::launch::deferred != 0), puis convertis async args... la même manière que par le constructeur std::thread, mais ne lance pas un nouveau thread d'exécution. Au lieu de cela,' évaluation paresseuse est réalisée: le premier appel à un non-chronométré attendre fonction sur le std::future que async renvoyé à l'appelant fera f(args...) être exécuté dans le thread courant. Tous les accès supplémentaires à la même std::future retournera le résultat immédiatement .

  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.

• Si drapeaux à la fois le std::launch::async et std::launch::deferred sont mis en policy, c'est à la mise en œuvre s'il faut effectuer l'exécution asynchrone ou l'évaluation paresseuse .

  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.

[modifier] Paramètres

[modifier] Retourne la valeur

[modifier] Exceptions

[modifier] Notes

[modifier] Exemple

#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