Espaces de noms
Variantes
    Actions

      std::async

      De cppreference.com
      < cpp‎ | thread

      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


       
      C++
       
      Bibliothèque de support fil
      Threads
      Original:
      Threads
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      thread (C++11)
      this_thread espace de noms
      Original:
      this_thread namespace
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      get_id (C++11)
      yield (C++11)
      sleep_for (C++11)
      sleep_until (C++11)
      L'exclusion mutuelle
      Original:
      Mutual exclusion
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      mutex (C++11)
      timed_mutex (C++11)
      Gestion du verrouillage générique
      Original:
      Generic lock management
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      lock_guard (C++11)
      unique_lock (C++11)
      defer_lock_t
      try_to_lock_t
      adopt_lock_t      		 (C++11)
      (C++11)
      (C++11)
      lock (C++11)
      try_lock (C++11)
      defer_lock
      try_to_lock
      adopt_lock      		 (C++11)
      (C++11)
      (C++11)
      Les variables de condition
      Original:
      Condition variables
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      condition_variable (C++11)
      condition_variable_any (C++11)
      notify_all_at_thread_exit (C++11)
      cv_status (C++11)
      Futures
      Original:
      Futures
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      promise (C++11)
      future (C++11)
      shared_future (C++11)
      packaged_task (C++11)
      async (C++11)
      launch (C++11)
      future_status (C++11)
      future_error (C++11)
      future_category (C++11)
      future_errc (C++11)
       
      Déclaré dans l'en-tête <future>
      template<class Function, class... Args>

      std::future<typenamestd::result_of<Function(Args...)>::type>

          async( Function&& f, Args&&... args);
      		 (1) (depuis C++11)
      template<class Function, class... Args>

      std::future<typenamestd::result_of<Function(Args...)>::type>

          async(std::launch policy, Function&& f, Args&&... args);
      		 (2) (depuis C++11)
      Le async fonction de modèle exécute la fonction f asynchrone (potentiellement dans un thread séparé) et renvoie une std::future qui finira par contenir le résultat de cet appel de fonction .
      Original:
      The template function async runs the function f asynchronously (potentially in a separate thread) and returns a std::future that will eventually hold the result of that function call.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      1)
      Se comporte comme async(std::launch::async|std::launch::deferred, f, args...). En d'autres termes, f peut être démarré dans un nouveau thread ou il peut être exécuté de façon synchrone lorsque le std::future résultant est interrogé pour une valeur .
      Original:
      Behaves the same as async(std::launch::async|std::launch::deferred, f, args...). In other words, f may be started in a new thread or it may be run synchronously when the resulting std::future is queried for a value.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      2)
      Appelle une fonction avec des arguments fargs selon une politique de lancement spécifique policy:
      Original:
      Calls a function f with arguments args according to a specific launch policy policy:
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      • 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 asyncargs... 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.

      Sommaire

      [modifier]Paramètres

      f -
      objet fonction ou la fonction à appeler
      Original:
      function or function object to call
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      args... -
      paramètres à passer au f
      Original:
      parameters to pass to f
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      policy -
      valeur masque, où chaque bit de contrôler les méthodes autorisées d'exécution
      Bit
      Explication
      Original:
      Explanation
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      std::launch::async
      permettre l'évaluation asynchrone
      Original:
      enable asynchronous evaluation
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      std::launch::deferred
      permettre l'évaluation paresseuse
      Original:
      enable lazy evaluation
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Original:
      bitmask value, where individual bits control the allowed methods of execution
      Bit
      Explication
      Original:
      Explanation
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      std::launch::async
      permettre l'évaluation asynchrone
      Original:
      enable asynchronous evaluation
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      std::launch::deferred
      permettre l'évaluation paresseuse
      Original:
      enable lazy evaluation
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      [modifier]Retourne la valeur

      std::future se référant à la valeur de retour de la fonction .
      Original:
      std::future referring to the return value of the function.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      [modifier]Exceptions

      Lance std::system_error avec std::errc::resource_unavailable_try_again condition d'erreur si la politique de lancement est std::launch::async et la mise en œuvre est incapable de démarrer un nouveau thread .
      Original:
      Throws std::system_error with error condition std::errc::resource_unavailable_try_again if the launch policy is std::launch::async and the implementation is unable to start a new thread.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      [modifier]Notes

      La mise en œuvre peut étendre le comportement de la première surcharge de std::async en permettant à d'autres (définie par l'implémentation) bits dans la politique de lancement par défaut .
      Original:
      The implementation may extend the behavior of the first overload of std::async by enabling additional (implementation-defined) bits in the default launch policy.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      [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)returnstd::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';}

      Résultat : 

      The sum is 10000
      Récupérée de « https://fr.cppreference.com/mwiki/index.php?title=cpp/thread/async&oldid=49862 »
      close