boost库学习随记六：使用同步定时器、异步定时器、bind、成员函数回调处理、多线程的同步处理示例等

一、使用同步定时器

这个示例程序通过展示如何在一个定时器执行一个阻塞等待。

//makefile  

#----------------------------------------------------------  

#makefile helloworld测试用例  

#  

#-----------------------------------------------------------  

ggg=g++  

exe=asiotimer  

#所有的.o文件写在这里  

obj = asiotimer.o  

#所要关联的cpp文件写在这里  

cpp = asiotimer.cpp  

#加入库文件  

libso = -lboost_thread -lboost_system  

$(exe):$(obj)  

        @echo "链接开始................"  

        $(ggg) $(libso) -o $(exe) $(obj)  

hw.o : $(cpp)  

        @echo "编译开始................"  

        $(ggg) -std=c++11 -c $(cpp)  

.PHONY : clean cleanall  

cleanall:  

        @echo "开始make all..........."  

        -rm -rf $(exe) $(obj)  

clean:  

        @echo "开始清理................"  

        -rm -rf $(obj)  

2、asiotimer.h头文件

//asiotimer.h  

#ifndef __ASIOTIMER__H__  

#define __ASIOTIMER__H__  

#include <iostream>  

#include <boost/asio.hpp>  

//#define BOOST_DATE_TIME_SOURCE  

#include "boost/date_time/posix_time/posix_time.hpp"  

#endif  

3、asiotimer.cpp文件

//asiotimer.cpp  

#include "asiotimer.h"  

int main()  

{  

        boost::asio::io_service io;  

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

        t.wait();  

        std::cout<<"hello,world\n";  

        return 0;  

}  

二、使用异步定时器示例

本示例程序演示了如何使用Asio的异步回调功能由示例一修改程序 ，开启计时器执行一个异步等待。

1、makefile文件

makefile 与示例一基本相同，只需要修改

exe=asiotest2

#所有的.o文件写在这里

obj = asiotest2.o

#所要关联的cpp文件写在这里

cpp = asiotest2.cpp

2、asiotest2.h

#ifndef __ASIOTEST2__H__  

#define __ASIOTEST2__H__  

#include <boost/date_time/posix_time/posix_time.hpp>  

void print(const boost::system::error_code& );  

3、asiotest2.cpp

#include "asiotest2.h"  

using namespace std;  

using namespace boost;  

void print(const boost::system::error_code& )  

        std::cout<<"hello,world!\n";  

        t.async_wait(&print);  

        io.run();  

三、绑定参数到处理程序

在本示例中，我们将在示例二修改程序，使定时器每秒被激活一次。这将显示如何传递额外的参数给你的处理函数。

1、makefile 文件同示例二makefile修改方法

2、头文件

#ifndef __ASIOTEST3__H__  

#define __ASIOTEST3__H__  

#include <boost/bind.hpp>  

3、CPP文件

#include "asiotest3.h"  

void print(const boost::system::error_code&,  

        boost::asio::deadline_timer* t,int* count)  

        if(*count<5)  

        {  

                std::cout<<*count<<"\n";  

                ++(*count);  

                t->expires_at(t->expires_at() + boost::posix_time::seconds(1));  

                t->async_wait(boost::bind(print,  

                        boost::asio::placeholders::error,t,count));  

        }  

        int count=0;  

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

        t.async_wait(boost::bind(print,boost::asio::placeholders::error,  

                        &t,&count));  

        std::cout<<"Final count is" <<count<<"\n";  

四、使用成员函数做为处理程序示例

在本示例中，我们将看到如何使用一个类的成员函数作为回调处理程序。

1、makefile 同上面示例

#ifndef __ASIOTEST4__H__  

#define __ASIOTEST4__H__  

class printer  

public:  

        printer(boost::asio::io_service& io)  

                :timer_(io,boost::posix_time::seconds(1)),  

                count_(0)  

                timer_.async_wait(boost::bind(&printer::print,this));  

        ~printer()  

                std::cout<<"Final count is "<<count_<<"\n";  

        void print()  

                if(count_<5)  

                {  

                        std::cout<<count_<<std::endl;  

                        ++count_;  

                        timer_.expires_at(timer_.expires_at()+boost::posix_time::seconds(1));  

                        timer_.async_wait(boost::bind(&printer::print,this));  

                }  

private:  

        boost::asio::deadline_timer timer_;  

        int count_;  

};  

3、cpp文件

#include "asiotest4.h"  

        printer p(io);  

五、多线程的同步处理示例

本示例演示boost::asio::strand 在多线程程序中同步回调处理程

1、makefile同上

#ifndef __ASIOTEST5__H__  

#define __ASIOTEST5__H__  

#include <boost/thread/thread.hpp>  

        printer(boost::asio::io_service& io):strand_(io),  

                timer1_(io,boost::posix_time::seconds(1)),  

                timer2_(io,boost::posix_time::seconds(1)),count_(0)  

                timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1,this)));  

                timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2,this)));  

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

        void print1()  

                if(count_ < 10)  

                        std::cout<<"Timer 1: "<<count_<<std::endl;  

                        timer1_.expires_at(timer1_.expires_at() + boost::posix_time::seconds(1));  

                        timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1,this)));  

        void print2()  

                        std::cout<<"Timer 2: " <<count_<<std::endl;  

                        timer2_.expires_at(timer2_.expires_at() + boost::posix_time::seconds(1));  

                        timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2,this)));  

        boost::asio::strand strand_;  

        boost::asio::deadline_timer timer1_;  

        boost::asio::deadline_timer timer2_;  

#endif   

#include "asiotest5.h"  

  boost::asio::io_service io;  

  printer p(io);  

  boost::thread t(boost::bind(&boost::asio::io_service::run,&io));  

  io.run();  

  t.join();  

  return 0;  

}

from:

<a href="http://blog.csdn.net/leitianjun/article/details/25740633">http://blog.csdn.net/leitianjun/article/details/25740633</a>