1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Comment asynchroniser et Attendre en C + + 11?

abdelouafiJan 23, 2017

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      202
      Likes Received:
      9
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      En C #, il ya async qui vous permet d'écrire le code asynchrone facilement par exemple. Faire quelques calculs tout en récupérant certaines données d'E / S. Le code asynchrone améliore la réactivité et est considéré comme une façon pratique d'écrire une application multithreading.
      async_all_the_things-1.jpg

      En C ++ 11, l'écriture du code asynchrone devient simple. Voir ci-dessous l'exemple qui résume un tableau 'grand' en divisant récursivement en deux moitiés (deux threads).


      Code:
      #include <iostream>
      
      #include <vector>
      
      #include <future>
      
      
      // pour l'utilisation de std::accumulate
      
      #if _MSC_VER
      
      #include <numeric>  // in Visual Studio
      
      #else
      
      #include <algorithm>  // g++ -std=c++14 -pthread parallel_sum.cpp
      
      #endif
      
      
      using namespace std;
      
      
      // generic
      
      template <typename TYPE>
      
      int parallel_sum(TYPE beg, TYPE end) {
      
          // block size
      
          auto len = end - beg;
      
          if (len < 500) {
      
              // Si le bloc est assez petit, il est plus rapide de les résumer.
      
              return std::accumulate(beg, end, 0);
      
          }
      
          // (beg + end) / 2 may overflow
      
          auto mid = beg + len / 2;
      
          // sum the left part asynchronously
      
          auto handle_left = std::async(launch::async, parallel_sum<TYPE>, beg, mid);
      
          // sum the right part asynchronously
      
          auto handle_right = std::async(launch::async, parallel_sum<TYPE>, mid, end);
      
          // put them together
      
          return handle_left.get() + handle_right.get();
      
      }
      
      
      int main() {
      
          vector<int> v(10000, 1);
      
          cout << "Sum: " << parallel_sum(v.begin(), v.end()) << endl;
      
      }


      Pour le compiler en Linux à l'aide du compilateur gcc, vous devez inclure le support de pthread et utiliser la syntaxe de C ++ 11,


      G ++ -std = c ++ 14 -pthread parallel_sum.cpp

      La méthode .get () est l'opération 'attendre', mais vous n'avez évidemment pas besoin du mot clé 'async'. Lorsque la taille de partition est assez petite, il est généralement considéré comme plus efficace de sommer les éléments localement en utilisant une boucle for (CPU bénéficie des lignes de cache locales, par exemple, plus de cache hits) ou dans ce cas le std :: accumulate.


      Le mot clé launch :: async spécifie qu'un nouveau thread doit être créé pour appeler la fonction. Le std :: async prend alors le nom de la fonction et ses paramètres (longueur variable des paramètres).
       
      Loading...

Share This Page

Share