准确的连续计时器回调

Question

我有一个应用程序，我希望每x毫秒显示一个帧。

以前我做的是这样的：

class SomeClass 
{ 
    boost::thread thread_; 
    boost::timer timer_; 
public: 
    SomeClass() : thread_([=]{Display();}) 
    { 
    } 

    void Display 
    {  
     double wait = 1.0/fps*1000.0;  
     while(isRunning_) 
     { 
      double elapsed = timer.elapsed()*1000.0; 
      if(elapsed < wait) 
        boost::this_thread::sleep(boost::posix_time::milliseconds(static_cast<unsigned int>(wait - elapsed))); 
      timer.restart(); 

      // ... Get Frame. This can block while no frames are being rendered. 

      // ... Display Frame. 
     } 
    } 
} 

不过，我不认为解决方案有很好的精度。我可能错了？

我希望能用boost :: asio :: deadline_timer代替，但我不确定如何使用它。

这是我试过的，这似乎没有等待。它似乎只是尽可能快地渲染帧。

class SomeClass 
    { 
     boost::thread thread_; 
     boost::asio::io_service io_; 
     boost::asio::deadline_timer timer_; 

    public: 
     SomeClass() : timer_(io_, 1.0/fps*1000.0) 
     { 
      timer_.async_wait([=]{Display();}); 
      thread_ = boost::thread([=]{io_.run();}) 
     } 

     void Display 
     {  
       double wait = 1.0/fps*1000.0;  
       while(isRunning_) 
       { 
        timer_.expires_from_now(boost::posix_time::milliseconds(wait_)); // Could this overflow? 

        // ... Get Frame. This can block while no frames are being rendered. 

        // ... Display Frame. 

        timer_.async_wait([=]{Display();}); 
       } 
     } 
    } 

我在做什么错？如果我得到这个解决方案的工作会比第一个更好吗？

Answer 1

请记住，帧的显示精度受显示器的刷新率限制（典型值为60 Hz显示器为17 ms，75 Hz显示器为13 ms）。如果你没有同步到显示刷新，那么你有一个不确定的延迟0-17毫秒，以添加到你使用的任何计时方法，因此精度并不需要比10毫秒好得多（甚至1毫秒可能是矫枉过正）。

Answer 2

下面是使用boost::asio::deadline_timer一个相当简单的例子，希望这有助于

#include <boost/asio.hpp> 
#include <boost/bind.hpp> 
#include <boost/enable_shared_from_this.hpp> 

#include <iostream> 

class Timer : public boost::enable_shared_from_this<Timer> 
{ 
public: 
    Timer(
      boost::asio::io_service& io_service 
     ) : 
     _io_service(io_service), 
     _timer(io_service) 
    { 

    } 

    void start() { 
     _timer.expires_from_now(
       boost::posix_time::seconds(0) 
       ); 
     _timer.async_wait(
       boost::bind(
        &Timer::handler, 
        shared_from_this(), 
        boost::asio::placeholders::error 
        ) 
       ); 
    } 

private: 
    void handler(
      const boost::system::error_code& error 
      ) 
    { 
     if (error) { 
      std::cerr << error.message() << std::endl; 
      return; 
     } 

     std::cout << "handler" << std::endl; 
     _timer.expires_from_now(
       boost::posix_time::seconds(1) 
       ); 
     _timer.async_wait(
       boost::bind(
        &Timer::handler, 
        shared_from_this(), 
        boost::asio::placeholders::error 
        ) 
       ); 
    } 

private: 
    boost::asio::io_service& _io_service; 
    boost::asio::deadline_timer _timer; 
}; 

int 
main() 
{ 
    boost::asio::io_service io_service; 
    boost::shared_ptr<Timer> timer(
      new Timer(io_service) 
      ); 
    timer->start(); 
    io_service.run(); 
}