停止长睡眠线程

Question

假设我有一个线程应该定期执行某些任务，但这段时间每小时 6 次 每小时 12 次（每 5 分钟一次），我经常看到控制线程的代码带有 is_running 标志的循环，每个循环都会检查该标志，如下所示：

std::atomic<bool> is_running;

void start()
{
    is_running.store(true);
    std::thread { thread_function }.detach();
}

void stop()
{
    is_running.store(false);
}

void thread_function()
{
    using namespace std::literals;
    while (is_running.load())
    {
        // do some task...
        std::this_thread::sleep_for(5min);
    }
}

但是，如果调用 stop() 函数，假设在 start() 之后 1 毫秒，线程将再存活 299999 毫秒，直到它唤醒、检查标志并死亡。

我的理解正确吗？如何避免保持本应结束的线程存活（但休眠）？到目前为止，我最好的方法如下：

void thread_function()
{
    using namespace std::literals;
    while (is_running.load())
    {
        // do some task...
        for (unsigned int b = 0u, e = 1500u; is_running.load() && (b != e); ++b)
        {
            // 1500 * 200 = 300000ms = 5min
            std::this_thread::sleep_for(200ms);
        }
    }
}

有没有更简单直接的方法来实现这一点？

Answer 1

使用条件变量。您等待条件变量 或 5 分钟过去。记得检查虚假唤醒。

cppreference

我在谷歌搜索的一两分钟内找不到关于如何使用条件变量的好的堆栈溢出帖子。棘手的部分是意识到wait 既不会经过 5 分钟，也不会在发送信号的情况下唤醒。处理此问题的最简洁方法是使用带有 lambda 的 wait 方法，该方法会仔细检查唤醒是否“良好”。

here 是 cppreference 上的一些示例代码，它使用 wait_until 和 lambda。 （带有 lambda 的wait_for 等效于带有 lambda 的 wait_until）。我稍微修改了一下。

这是一个版本：

struct timer_killer {
  // returns false if killed:
  template<class R, class P>
  bool wait_for( std::chrono::duration<R,P> const& time ) const {
    std::unique_lock<std::mutex> lock(m);
    return !cv.wait_for(lock, time, [&]{return terminate;});
  }
  void kill() {
    std::unique_lock<std::mutex> lock(m);
    terminate=true; // should be modified inside mutex lock
    cv.notify_all(); // it is safe, and *sometimes* optimal, to do this outside the lock
  }
  // I like to explicitly delete/default special member functions:
  timer_killer() = default;
  timer_killer(timer_killer&&)=delete;
  timer_killer(timer_killer const&)=delete;
  timer_killer& operator=(timer_killer&&)=delete;
  timer_killer& operator=(timer_killer const&)=delete;
private:
  mutable std::condition_variable cv;
  mutable std::mutex m;
  bool terminate = false;
};

live example.

您在共享位置创建timer_killer。客户端线程可以wait_for( time )。如果它返回 false，则表示您在等待完成之前就被杀死了。

控制线程只调用kill()，每个执行wait_for 的人都会得到false 返回。

请注意，存在一些争用（互斥锁的锁定），因此这不适合无限线程（但很少有）。如果您需要无限数量的任务以任意延迟运行而不是每个延迟重复任务的完整线程，请考虑使用调度程序 - 每个实际线程使用的系统地址空间超过 1 兆字节（仅用于堆栈） .

Answer 2

有两种传统方法可以做到这一点。

您可以在条件变量上使用定时等待，并让另一个线程向您的周期性线程发出信号，以便在该时间时唤醒并终止。

或者，您可以在管道上 poll 将您的睡眠作为超时而不是睡眠。然后你只需向管道写入一个字节，线程就会唤醒并退出。

Answer 3

是的，通过std::mutex、std::lock_guard和std::conditional_variable：

std::mutex mtx;
std::conditional_variable cv;

void someThreadFunction (){
   while(!stopThreadFlag){
     std::lock_gurad<std::mutex> lg(mtx);
     cv.wait_for(lg,SOME_ITERVAL,!stopThreadFlag || wakeTheThreadVariable);
     //the rest here
  }
}