boost timer代码学习笔记

socket连接中需要判断超时

所以这几天看了看boost中计时器的文档和示例

一共有五个例子 从简单的同步等待到异步调用超时处理

先看第一个例子

 // timer1.cpp: 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <iostream>
 #include <boost/asio.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>

 void print() {
     std::cout << "Hello world" << std::endl;
 }

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

     boost::asio::deadline_timer t(io,boost::posix_time::seconds());
     t.wait();

     print();

     return ;
 }

timer

几行代码 简单的声明计时器 等待五秒后继续执行

但是代码有一个问题就是 等待时间内 流程是卡死的

所以加以改进就是例子2 更改为异步等待

 // timer2.cpp: 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <iostream>
 #include <boost/asio.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>

 void print(const boost::system::error_code&) {
     std::cerr << "Hello world!" << std::endl;
 }

 int main()
 {
     boost::asio::io_service io;
     boost::asio::deadline_timer t(io,boost::posix_time::seconds());
     t.async_wait(&print);
     for (int i = ; i < ; i++) {
         std::cout << "wait" << std::endl;
     }
     io.run();

     return ;
 }

timer2

例子3又添加了一个内容

异步等待函数中 再次设置异步等待时间和超时异步调用的回调函数

一共5次  由于传入的是计数count变量的指针 所以计数变量会累加

当累加到5 则不再继续

代码如下：

 // timer3.cpp: 定义控制台应用程序的入口点。
 //
 #include <iostream>
 #include <boost/asio.hpp>
 #include <boost/bind.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>

 void print(const boost::system::error_code& /*e*/,
     boost::asio::deadline_timer* t, int* count)
 {
     if (*count < )
     {
         std::cout << *count << std::endl;
         ++(*count);

         t->expires_at(t->expires_at() + boost::posix_time::seconds());
         t->async_wait(boost::bind(print,
             boost::asio::placeholders::error, t, count));
     }
 }

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

     int count = ;
     boost::asio::deadline_timer t(io, boost::posix_time::seconds());
     t.async_wait(boost::bind(print,
         boost::asio::placeholders::error, &t, &count));

     io.run();

     std::cout << "Final count is " << count << std::endl;

     return ;
 }

timer3

例子4同例子3 不同之处在于 以类的形式封装了超时异步回调函数以及timer

 // timer4.cpp: 定义控制台应用程序的入口点。
 //
 #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_ << std::endl;
     }

     void print()
     {
         if (count_ < )
         {
             std::cout << count_ << std::endl;
             ++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 ;
 }

timer4

例子5开启了两个timer分别在不同线程中运行

基本上阅读没有任何问题

但是实际编写中要深入了解 asio::io_service::strand 和 多线程运行ioser.run（）

这两点需要注意 可以尝试不适用strand_.wrap

运行代码比对代码运行结果进行理解

代码如下

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

 class printer
 {
 public:
     printer(boost::asio::io_service& io)
         : strand_(io),
         timer1_(io, boost::posix_time::seconds()),
         timer2_(io, boost::posix_time::seconds()),
         count_()
     {
         timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, this)));
         timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, this)));
     }

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

     void print1()
     {
         if (count_ < )
         {
             std::cout << "Timer 1: " << count_ << std::endl;
             ++count_;

             timer1_.expires_at(timer1_.expires_at() + boost::posix_time::seconds());
             timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, this)));
         }
     }

     void print2()
     {
         if (count_ < )
         {
             std::cout << "Timer 2: " << count_ << std::endl;
             ++count_;

             timer2_.expires_at(timer2_.expires_at() + boost::posix_time::seconds());
             timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, this)));
         }
     }

 private:
     boost::asio::io_service::strand strand_;
     boost::asio::deadline_timer timer1_;
     boost::asio::deadline_timer timer2_;
     int count_;
 };

 int main()
 {
     boost::asio::io_service io;
     printer p(io);
     boost::thread t(boost::bind(&boost::asio::io_service::run, &io));
     io.run();
     t.join();

     return ;
 }

timer5