分类导航

C&C++ 发布时间：2022-04-03 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了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));
  }
}

而且线程正在休眠.如果在线程之外发生了某些事情,我希望能够增加睡眠时间.

最好的方法是什么？

@R_404_1964@

使用COndition_variable发出更改截止日期的信号

这有利于支持缩短超时的方案：

见它Live On Coliru

#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();
}

C 11标准库(无信令)

这是一种仅限标准库的方法,在截止日期前不使用同步.

我更倾向于使用原子time_point作为截止时间值本身,但这不受支持.接下来最好的事情就是shared_ptr< time_point> (使用std :: atomic_load / atomic_storE)但我的编译器库尚未实现(grrr).

所以,相反,我从开始时间开始分享’偏移’：

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

namespace demo
{
    namespace chrono = std::chrono;

    using our_clock = chrono::system_clock;
    using shared_delay = std::atomic<our_clock::duration>;

    void worker(our_clock::time_point const start,shared_delay const& delay)
    {
        for (our_clock::time_point deadline; our_clock::Now() < (deadline = start + delay.load());)
        {
            std::cout << "worker: Sleeping for " << chrono::duration_cast<chrono::milliseconds>(deadline - our_clock::Now()).count() << "ms...\n";
            std::this_thread::sleep_until(deadlinE);
        }

        std::cout << "worker: Done\n";
    }
}

int main()
{
    using namespace demo;

    shared_delay delay(chrono::seconds(2));
    auto th = std::thread(worker,our_clock::Now(),std::cref(delay));

    // after 2 seconds,update the timepoint
    std::this_thread::sleep_for(chrono::seconds(1));
    std::cout << "updating shared delay value..." << "\n";
    delay.store(chrono::seconds(3));

    th.join();
}