C++ 重置线程的睡眠时间

假设有一根这样的线

void mythread()
{
  int res;
  while(1) {
    {
       boost::lock_guard<boost::mutex> lock(mylock);
       res = do_my_stuff();
    }
    boost::this_thread::sleep(boost::posix_time::seconds(5));
  }
}

void mythread（）
{
国际关系；
而(1){
{
增压：锁和防护锁（mylock）；
res=做我的事（）；
}
boost：：this_线程：：sleep（boost：：posix_时间：：秒（5））；
}
}

线程当前正在休眠。如果线程之外发生了什么，我希望能够增加睡眠时间

---

最好的方法是什么？

这里有一个快速而肮脏的方法：

volatile bool someCondition=false；
来自其他线程的无效调用（bool x）{
boost：：锁_防护锁（mylock2）；
someCondition=x；
}
void mythread（）
{
国际关系；
而(1){
bool keepwaiting=false；
{
boost：：锁_防护锁（mylock2）；
保持等待=某种条件；
}
如果（！keepwaiting）{
增压：锁和防护锁（mylock）；
res=做我的事（）；
}
boost：：this_线程：：sleep（boost：：posix_时间：：秒（5））；
}
}

当你的线程完成睡眠后，它会检查是否发生了“其他事情”，如果发生了，它会跳过“do_my_stuff（）”并再次进入睡眠状态

我猜想，如果您有更多关于用例的信息，就有可能重写一些东西来使用条件变量。

使用

condition\u变量

来表示对截止日期的更改 这有利于支持缩短超时时间的场景：

查看它

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

namespace demo
{
    namespace chrono = std::chrono;

    using our_clock = chrono::system_clock;

    struct Worker
    {
        mutable std::mutex _mx;

        // shared, protected by _mx:
        our_clock::time_point _deadline; 
        mutable std::condition_variable _cv;

        Worker(our_clock::time_point deadline) : _deadline(deadline) {}

        void operator()() const {
            std::unique_lock<std::mutex> lk(_mx);
            _cv.wait_until(lk, _deadline, [this] 
                    { 
                        std::cout << "worker: Signaled\n";
                        auto now = our_clock::now();
                        if (now >= _deadline)
                            return true;
                        std::cout << "worker: Still waiting " << chrono::duration_cast<chrono::milliseconds>(_deadline - now).count() << "ms...\n"; 
                        return false;
                    });
            std::cout << "worker: Done\n";
        }
    };
}

int main()
{
    using namespace demo;

    Worker worker(our_clock::now() + chrono::seconds(2));
    auto th = std::thread(std::cref(worker));

    // after 2 seconds, update the timepoint
    std::this_thread::sleep_for(chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lk(worker._mx);
        std::cout << "Updating shared delay value..." << "\n";

        worker._deadline = our_clock::now() + chrono::seconds(1);
        worker._cv.notify_all();
    }

    th.join();
}

---

请参见使用条件变量并测量衍生线程之外的运行时间。根据需要发出信号。不要使用线程。改用定时器。然后可以修改计时器的间隔。您还可以获得其他好处，例如无需等待睡眠就可以停止计时器，并且睡眠线程不会占用内存或阻塞线程池。

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

namespace demo
{
    namespace chrono = std::chrono;

    using our_clock = chrono::system_clock;

    struct Worker
    {
        mutable std::mutex _mx;

        // shared, protected by _mx:
        our_clock::time_point _deadline; 
        mutable std::condition_variable _cv;

        Worker(our_clock::time_point deadline) : _deadline(deadline) {}

        void operator()() const {
            std::unique_lock<std::mutex> lk(_mx);
            _cv.wait_until(lk, _deadline, [this] 
                    { 
                        std::cout << "worker: Signaled\n";
                        auto now = our_clock::now();
                        if (now >= _deadline)
                            return true;
                        std::cout << "worker: Still waiting " << chrono::duration_cast<chrono::milliseconds>(_deadline - now).count() << "ms...\n"; 
                        return false;
                    });
            std::cout << "worker: Done\n";
        }
    };
}

int main()
{
    using namespace demo;

    Worker worker(our_clock::now() + chrono::seconds(2));
    auto th = std::thread(std::cref(worker));

    // after 2 seconds, update the timepoint
    std::this_thread::sleep_for(chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lk(worker._mx);
        std::cout << "Updating shared delay value..." << "\n";

        worker._deadline = our_clock::now() + chrono::seconds(1);
        worker._cv.notify_all();
    }

    th.join();
}