【Boost】boost库中timer定时器 1

博客转载自：http://blog.csdn.net/liujiayu2/article/details/50384537

同步Timer

asio中提供的timer名为deadline_timer，它提供了超时计时的功能。首先以一个最简单的同步Timer为例来演示如何使用它。

 #include <iostream>
 #include <boost/asio.hpp>

 int main()
 {
    boost::asio::io_service io;
    boost::asio::deadline_timer timer(io, boost::posix_time::seconds());

    timer.wait();
    std::cout << "Hello, world!\n";
    return ;
}

首先常见了一个io_service对象，它提供了IO调度功能，asio库中的所有io操作都是基于它来执行的。然后创建了一个deadline_timer对象，它有两个参数，一个是io_service对象，另一个是超时时间。

创建了timer后，就可以调用wait函数来阻塞等待至timer超时了，它还有一种可以指定错误码的入参的重载形式，关于错误码后面再介绍。

异步Timer

同步timer虽然简单，但由于其会阻塞，在实际的项目中并不常用，而往往使用的是异步timer：指定一个回调函数，计时器超时后执行回调函数。asio中实现异步timer比较简单，示例如下：

void print(const boost::system::error_code& /*e*/)
{
    std::cout << "Hello, world!\n";
}

int main()
{
    boost::asio::io_service io;
    boost::asio::deadline_timer timer(io, boost::posix_time::seconds());

    timer.async_wait(&print);
    io.run();

    return ;
}

和同步方式相比，它主要有两点不同：

1. 调用的是非阻塞函数async_wait，它的入参是一个回调函数。
2. 显式调用io_service.run()函数驱动异步IO调度。

取消Timer

void print(const boost::system::error_code& err)
    {
        if(err)
        {
            std::cout << "timer is canceled\n";
            return;
        }

        std::cout << "Hello, world!\n";
    }

    int main()
    {
        boost::asio::io_service io;

        boost::asio::deadline_timer timer(io, boost::posix_time::seconds());
        timer.async_wait(&print);

        boost::asio::deadline_timer timer2(io, boost::posix_time::seconds());
        timer2.wait();
        timer.cancel();

        io.run();
        return ;
    }

更改Timer超时时间

可以通过expires_from_now和expires_at两个函数更改Timer的超时时间，如下示例就通过它实现一个周期计时器。

Timer还有一种常用操作是取消Timer，基本方法如下：

1. 调用timer的cancel函数取消timer
2. timer取消后，回调函数会立即执行，通过err_code可以感知到计时器是否已经被取消

typedef std::function<void (const boost::system::error_code&)> timer_callback ;
    void print(const boost::system::error_code&)
    {
        std::cout << "Hello, world!\n";
    }

    int main()
    {
        boost::asio::io_service io;
        boost::asio::deadline_timer timer(io, boost::posix_time::seconds());

        timer_callback callback = [&](const boost::system::error_code& err)
        {
            print(err);
            timer.expires_at(timer.expires_at() + boost::posix_time::seconds());
            timer.async_wait(callback);
        };

        timer.async_wait(callback);
        io.run();
        return ;
    }

//

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>  

class printer
{
public:
  printer(boost::asio::io_service& io)
    : timer_(io, boost::posix_time::seconds()),
      count_()
  {
    timer_.async_wait(boost::bind(&printer::print, this));
  }  

  ~printer()
  {
    std::cout << "Final count is " << count_ << "\n";
  }  

  void print()
  {
    if (count_ < )
    {
      std::cout << count_ << "\n";
      ++count_;  

      timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds());
      timer_.async_wait(boost::bind(&printer::print, this));
    }
  }  

private:
  boost::asio::deadline_timer timer_;
  int count_;
};  

int main()
{
  boost::asio::io_service io;
  printer p(io);
  io.run();  

  return ;
}  

//

#include <iostream>
#include <time.h>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>    

using namespace std;  

//超时控制器类
class TimerController
{
public:  

    /**
     * 超时控制器构造函数
     * @param ios 异步I/O对象
     * @param callbackFunc 超时处理回调函数
     * @param uiWaitSec 定时器间隔等待时间，单位：秒
     */
    explicit TimerController(boost::asio::io_service &ios, boost::function<void()> callbackFunc, unsigned int uiWaitSec) :
            m_timer(ios, boost::posix_time::seconds())
    {
        cout<< "" << "-----" << time(NULL)<<endl;
        m_timeoutHandle = callbackFunc;
        m_uiWaitSec = uiWaitSec;
        m_timer.async_wait(boost::bind(&TimerController::onTime, this, boost::asio::placeholders::error));
    }  

    /**
     * 析构函数
     */
    ~TimerController()
    {
        m_timer.cancel();
    }  

    /**
     * 定时器响应函数
     * @param error_code 定时器异常错误信息
     */
    void onTime(const boost::system::error_code&)
    {
        m_timeoutHandle();
        m_timer.expires_at(m_timer.expires_at() + boost::posix_time::seconds());
        m_timer.async_wait(boost::bind(&TimerController::onTime, this, boost::asio::placeholders::error));
    }  

private:
    unsigned int                    m_uiWaitSec;                //定时间间隔等待时间
    boost::asio::deadline_timer     m_timer;                    //asio定时器
    boost::function<void()>           m_timeoutHandle;            //超时处理回调函数
};  

//构造函数
class CmdQueueManager
{
public:
    CmdQueueManager(boost::asio::io_service* io)
    {
        m_pTimer     = new TimerController(*io,boost::bind(&CmdQueueManager::SendProcess, this),);
    }  

    void SendProcess()
    {
        cout<< "" << "-----" << time(NULL)<<endl;
    }  

    TimerController *               m_pTimer;
};  

int main()
{
    boost::asio::io_service io;  

    CmdQueueManager t(&io);
    io.run();  

    return ;
} 

最近做项目时，做了一个定时器，发现定时器回调函数不按照指定时间回调，总是延迟，后经研究发现，是IO出了问题，把一个IO绑定到多个socket上面，并把这个IO绑定到定时器上面，有一些socket连接网络时发出了一些connect行为，这些行为会造成IO阻塞，当然这只是猜测，看到的读者可以帮忙讲解一下。所以本人建议做timer时候，自建一个人“干净”的IO。