De base de la minuterie avec std::thread et std::chrono

Je suis en train de mettre en œuvre une base de minuterie avec les méthodes classiques: start() et stop(). Je suis à l'aide de c++11 avec std::thread et std::chrono.

  • Méthode de démarrage. Crée un nouveau thread qui est endormi pour un intervalle donné de temps, puis d'exécuter un std::function. Ce processus est répété tout en un "running" du pavillon est vrai.
  • Méthode Stop. Juste définit la "running" du pavillon de faux.

J'ai créé et a commencé un objet Timer qui montrent "Bonjour!" à chaque seconde, puis avec d'autres thread, j'ai essayer de l'arrêt de la minuterie, mais je ne peux pas. Le chronomètre ne s'arrête jamais.

Je pense que le problème est avec th.join()[*] que s'arrête l'exécution jusqu'à ce que le thread a fini, mais quand j'enlève th.join() de la ligne, évidemment, le programme se termine avant que le compteur commence à compter.

Donc, ma question est comment faire pour exécuter un thread sans arrêt les autres threads?

#include <iostream>
#include <thread>
#include <chrono>

using namespace std;

class Timer
{
    thread th;
    bool running = false;

public:
    typedef std::chrono::milliseconds Interval;
    typedef std::function<void(void)> Timeout;

    void start(const Interval &interval,
               const Timeout &timeout)
    {
        running = true;

        th = thread([=]()
        {
            while (running == true) {
                this_thread::sleep_for(interval);
                timeout();
            }
        });

//[*]
        th.join();
    }

    void stop()
    {
        running = false;
    }
};

int main(void)
{
    Timer tHello;
    tHello.start(chrono::milliseconds(1000),
                 []()
    {
        cout << "Hello!" << endl;
    });

    thread th([&]()
    {
        this_thread::sleep_for(chrono::seconds(2));
        tHello.stop();
    });

    th.join();

    return 0;
}

De sortie:

Hello!
Hello!
...
...
...
Hello!
Comme un autre commentaire, dans mon expérience, en essayant de faire de même, à l'aide de condition_variable était plus efficace (parce qu'il a conçu pour ce genre de chose). Cependant, il rend le code moins claire.

OriginalL'auteur Sysyfydev | 2014-02-03

  1. 8

    Dans Timer::start, vous créez un nouveau thread dans th puis immédiatement join avec th.join(). Effectivement, start ne reviendra pas jusqu'à ce qui a engendré fil des sorties. Bien sûr, il ne sera plus jamais le quitter parce que rien ne fait courir de fausses jusqu'à ce que après start est de retour...

    Ne pas join un thread jusqu'à ce que vous avez l'intention d'attendre qu'elle se termine. Dans ce cas, en stop après la mise running = false est probablement le bon endroit.

    Aussi - même s'il n'est pas incorrect - il n'y a pas besoin de faire un autre thread dans main appeler this_thread::sleep_for. Vous pouvez simplement le faire avec le thread principal:

    int main()
{
    Timer tHello;
    tHello.start(chrono::milliseconds(1000), []{
        cout << "Hello!" << endl;
    });

    this_thread::sleep_for(chrono::seconds(2));
    tHello.stop();
}

    OriginalL'auteur Casey

  2. 1

    Au lieu de placer le join dans start placer après running = false dans stop. Ensuite, la méthode stop effectivement attendre jusqu'à ce que le thread est terminé avant de revenir.

    OriginalL'auteur hsun324