Partage
  • Partager sur Facebook
  • Partager sur Twitter

Multithreading C++

Comment exécuter un thread en background et récupérer les résultats

    25 août 2021 à 13:44:49

    Bonjour j'ai un problème concernant les threads.

    Voici mon code:

    test.cpp

    using namespace std;
    
    #include <stdio.h>
    #include <time.h>
    #include <iostream>
    #include <math.h>
    #include <cstdlib>
    #include <unistd.h>
    
    #include <iostream>
    #include <sstream>
    #include <thread>
    #include <vector>
    #include <future>
    
    #include "mychrono.hpp"
    
    int main()
    
    {
        
        std::vector<Chronometer*> car_crono;
        Chronometer chrono, output_chrono;
        std::vector<std::thread> threads;
    
        std::thread th;
        future<Chronometer> ft;
    
    
        while (1) {
           
    
            
            for(int i = 0; i < 1; i++)
            {
                car_crono.push_back(new Chronometer);
            }
    
            for(int i = 0; i<1; i++)
                {
            
                        //threads.push_back(std::thread(&Chronometer::start_chrono, car_crono[i], std::ref(chrono)));
                        auto ft = std::async(std::launch::async, [&chrono](){&Chronometer::start_chrono(chrono); });                 
                
                 }
            ft.get();
            // std::cout << "Threads size: " << threads.size();
            // for (auto &th : threads) {
            //            th.join(); 
            //             }
                
           std::cout << "Hello-world" << std::endl;
           
        }
    }


    mychrono.cpp

    #include "mychrono.hpp"
    
    #include <time.h>
    #include <iostream>
    #include <cstdlib>
    #include <unistd.h>
    
    #include <sstream>
    #include <thread>
    
    
    //int Chronometer::hour(0), min(0), sec(0);
    
    Chronometer::Chronometer() : hour(0), min(0), sec(0)
    {
    
    }
    
    Chronometer& Chronometer::start_chrono(Chronometer& chrono)
    {
     
      // if(chrono.hour == 0 && chrono.min == 0 && chrono.sec == 0)
      // {
        bool condition = true;
        while(condition) {
          sleep(1);
          chrono.sec++;
    
          if(sec > 59) {
            chrono.min++;
            chrono.sec = 0;
    
          }
    
          if(min > 59) {
            chrono.hour++;
            chrono.sec = 0;
            chrono.min = 0;
          }
          if(chrono.sec == 10)
          {
            condition = false;
          }
    
          std::cout << "chrono: " << chrono << std::endl;
    
       }
    
      //}  
    
      return chrono;
    }
    
    
    Chronometer& Chronometer::finish_chrono(Chronometer& chrono)
    {
        chrono.hour = 0;
        chrono.sec = 0;
        chrono.min = 0;
    
        return chrono;
    }
    
    
    std::ostream& operator<<(std::ostream& flux, Chronometer t)
    {
        flux << t.hour << ":" << t.min << ":" << t.sec;
        return flux;
    }
    
    Chronometer& Chronometer::operator=(const Chronometer& other)
    {
        // Guard self assignment
        if (this == &other)
            return *this;
    }
    
    Chronometer::~Chronometer(){}

    mychrono.hpp

    #include <time.h>
    #include <iostream>
    #include <sstream>
    
    #ifndef mychrono_hpp
    #define mychrono_hpp
    
    class Chronometer
    {
        private:
            
            //std::stringstream ss;
            //Chronometer chrono;
    
        public:
            int hour, min, sec;
    
            Chronometer();
            Chronometer& start_chrono(Chronometer& chrono);
            Chronometer& finish_chrono(Chronometer& chrono);
            friend std::ostream& operator<<(std::ostream& flux, Chronometer t);
            Chronometer& operator=(const Chronometer& other);
            ~Chronometer();
    
    };
    
    
    #endif

    L'objectif étant que dans mon test.cpp je puisse lancer ou arreter des chrono de type Chronometer en parallèle de la boucle while. Par exemple lancer deux chrono de type Chronometer avec start_chrono puis de pouvoir exécuter en parallèle des instructions comme print un simple message hello-world, puis arreter l'un des deux chronos par exemple pour en récupérer le résultat final.

    Le problème étant que dans les tests que j'ai fait soit mon chrono se lance de facon synchrone soit mon programme finit par crasher soit des erreurs syntaxiques. Etant nouveau en c++ et encore plus dans les threads je ne parviens pas depuis plusieurs jours à comprendre et finaliser ce que je souhaite.

    J'ai déjà posté mon problème ailleurs mais je ne trouve pas de solutions :(:

    https://stackoverflow.com/questions/68909406/terminate-called-after-throwing-an-instance-of-stdsystem-error/68911388#68911388

    https://stackoverflow.com/questions/68906234/error-no-matching-function-for-call-to-stdthread-invokerstdtuple/68906450#68906450

    Si quelqu'un s'y connait bien en thread je veux bien de l'aide.:)

    • Partager sur Facebook
    • Partager sur Twitter
      25 août 2021 à 14:07:45

      Salut,

      Je peux déjà te donner quelques conseils hormis le bug dont tu nous parles pour améliorer tes futurs codes.

      - N'utilise pas 'using namespace std;' c'est une mauvaise pratique: préfère prefixer std:: devant les objets/classes/fonctions de la bibliothèque standard.

      - Si un pointeur doit avoir l'ownership sur la ressource pointée alors tu devrais plutôt utiliser std::unique_ptr<T> qui se chargera de supprimer la ressource pointée le moment venu. Là tu utilise 'new' mais il n'y a nulle part de 'delete' donc tu as une fuite de mémoire potentielle (ou alors j'ai mal lu ton code).:)

      -
      Edité par Warren79 25 août 2021 à 14:08:38

      • Partager sur Facebook
      • Partager sur Twitter

      Mon site web de jeux SDL2 entre autres : https://www.ant01.fr

      Multithreading C++

      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
      • Editeur
      • Markdown