Approche de l'utilisation d'une STD :: Atomic par rapport à STD :: Condition_Variable WRT Pause & Reprenant un filet STD :: Thread en C ++

Une variable de condition est utile lorsque vous souhaitez arrêter de conditionnellement un autre fil ou non. Donc, vous pourriez avoir un fil "travailleur" toujours en cours qui attend quand il remarque qu'il n'a rien à faire pour être en cours d'exécution.

La solution atomique nécessite votre interaction interaction de l'interface utilisateur synchronisée avec le fil de travailleur ou une logique très complexe pour le faire de manière asynchrone . P>

en règle générale, votre thread de réponse de l'interface utilisateur ne doit jamais bloquer sur l'état non prête des threads de travailleur. P>

struct worker_thread {
  worker_thread( std::function<void()> t, bool play = true ):
    task(std::move(t)),
    execute(play)
  {
    thread = std::async( std::launch::async, [this]{
      work();
    });
  }
  // move is not safe.  If you need this movable,
  // use unique_ptr<worker_thread>.
  worker_thread(worker_thread&& )=delete;
  ~worker_thread() {
    if (!exit) finalize();
    wait();
  }
  void finalize() {
    auto l = lock();
    exit = true;
    cv.notify_one();
  }
  void pause() {
    auto l = lock();
    execute = false;
  }
  void play() {
    auto l = lock();
    execute = true;
    cv.notify_one();
  }
  void wait() {
    Assert(exit);
    if (thread)
      thread.get();
  }
private:
  void work() {
    while(true) {
      bool done = false;
      {
        auto l = lock();
        cv.wait( l, [&]{
          return exit || execute;
        });
        done = exit; // have lock here
      }
      if (done) break;
      task();
    }
  }
  std::unique_lock<std::mutex> lock() {
     return std::unique_lock<std::mutex>(m);
  }
  std::mutex m;
  std::condition_variable cv;
  bool exit = false;
  bool execute = true;
  std::function<void()> task;
  std::future<void> thread;
};