Подход к использованию std::atomic по сравнению с std::condition_variable относительно приостановки и возобновления std::thread в C++

Переменная условия полезна, когда вы хотите условно остановить другой поток или нет. Таким образом, у вас может быть постоянно работающий «рабочий» поток, который ждет, когда заметит, что ему нечего делать для запуска.

Атомарное решение требует, чтобы ваше взаимодействие с пользовательским интерфейсом синхронизировалось с рабочим потоком, или очень сложная логика, чтобы сделать это асинхронно.

Как правило, ваш поток ответа пользовательского интерфейса никогда не должен блокироваться в неготовом состоянии от рабочих потоков.

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;
};

или что-то в этом роде.

Это владеет нитью. Поток повторно запускает задачу, пока он находится в режиме play(). Если вы pause() в следующий раз, когда task() завершится, рабочий поток остановится. Если вы play() до завершения вызова task(), он не заметит pause().

Единственное ожидание — это уничтожение worker_thread, когда он автоматически информирует рабочий поток о том, что он должен выйти, и ждет его завершения.

Вы также можете вручную .wait() или .finalize(). .finalize() является асинхронным, но если ваше приложение закрывается, вы можете вызвать его раньше и дать рабочему потоку больше времени на очистку, в то время как основной поток выполняет очистку в другом месте.

.finalize() нельзя отменить.

Код не тестировался.

Если я что-то не упустил, вы уже ответили на это в своем первоначальном вопросе: вы будете создавать и уничтожать рабочий поток каждый раз, когда это необходимо. Это может или не может быть проблемой в вашем реальном приложении.

Решаются две разные проблемы, и это может зависеть от того, что вы на самом деле делаете. Одна проблема: «Я хочу, чтобы мой поток работал, пока я не скажу ему остановиться». Другой, кажется, случай «у меня есть пара производитель/потребитель, и я хочу иметь возможность уведомить потребителя, когда данные будут готовы». Метод thread_running и join хорошо работает для первого из них. Во-вторых, вы можете захотеть использовать мьютекс и условие, потому что вы делаете больше, чем просто используете состояние для запуска работы. Предположим, у вас есть vector<Work>. Вы охраняете это с помощью мьютекса, поэтому условие становится [&work] (){ return !work.empty(); } или чем-то подобным. Когда ожидание возвращается, вы держите мьютекс, чтобы вы могли взять вещи из работы и сделать их. Когда вы закончите, вы возвращаетесь к ожиданию, освобождая мьютекс, чтобы производитель мог добавить что-то в очередь.

Вы можете комбинировать эти техники. Имейте атомарную "выполненную обработку", которую все ваши потоки периодически проверяют, чтобы знать, когда выйти, чтобы вы могли присоединиться к ним. Используйте условие для случая доставки данных между потоками.