BOOST TCP 同步 网络通信

TCP服务器端：

#include <iostream>

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

int main( int argc, char * argv[] )
{
	//TCP服务器端-同步;
	//在同步模式下，程序发起一个IO操作，向io_service提交请求，io_service把操作转交给操作系统，同步地等待;
	//当IO操作完成时，操作系统通知io_service，然后io_service再把结果发回给程序，完成整个同步流程;
	//这个处理流程与多线程join()等待方式很相似【死等】;	
	{
		try
		{
			std::cout << "Server start." << std::endl;

			boost::asio::io_service ios;
			boost::asio::ip::tcp::endpoint ep( boost::asio::ip::tcp::v4(), 6688 );

			//创建acceptor对象:ipv4协议, 6688端口;
			boost::asio::ip::tcp::acceptor acceptor( ios, ep );

			std::cout << "Server : " << acceptor.local_endpoint().address() << std::endl;

			while ( true )
			{
				boost::asio::ip::tcp::socket sock( ios );

				//阻塞等待socket连接;
				acceptor.accept( sock );

				//获取远程断点IP地址;
				std::cout << "Client : " << sock.remote_endpoint().address() << std::endl;

				//接收数据;
				std::vector<char> str( 100, 0 );
				sock.read_some( boost::asio::buffer(str) );

				//输出至控制台;
				std::cout << "Recive from " << sock.remote_endpoint().address() << "Mes : " << &str[0] << std::endl;

				//发送数据;
				sock.write_some( boost::asio::buffer("hello client") );
			}
		}
		catch ( boost::system::system_error &e )
		{
			std::cout << "process failed : " << e.what() << std::endl;
		}
	}

	system( "pause" );
	return 0;
}

TCP客户端：
①自定义计时器

#ifndef LHCTimer_h__
#define LHCTimer_h__

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


// <summary> 自定义计时器，该计时器在second秒后结束，结束后执行func函数，循环countMax次; </summary>
// <remarks>    2017.6.8         </remarks>

class LHCTimer
{
public:
	
	// <summary> 自定义计时器的模板构造函数; </summary>
	//
	//   second:计时器Timer结束时间;
	//   countMax:计时器Timer执行的次数;
	//   func:计时器结束后，所要执行的外部函数;
	// <remarks>    2017.6.8         </remarks>
	
	template<typename F>
	LHCTimer( boost::asio::io_service &ios, int second, int countMax, F func );

	//回调函数，调用次数为Count_Max，回调函数为Fun();
	void CallFunc( const boost::system::error_code & )
	{
		if ( Count > Count_Max )
		{
			return;
		}

		++Count;
		Fun();

		D_Timer.expires_at( D_Timer.expires_at() + boost::posix_time::seconds( Seconds ) );  //设置定时器的终止时间为Seconds秒;
		D_Timer.async_wait( boost::bind(&LHCTimer::CallFunc, this, boost::asio::placeholders::error) );  //异步等待计时器,注册回调函数;
	}

private:
	int Count; //计数用;
	int Count_Max; //计时器Timer执行的次数;
	int Seconds; //计时器Timer结束时间;

	boost::function<void()> Fun; //计时器结束后，所要执行的外部函数;
	boost::asio::deadline_timer D_Timer; //计时器变量;
};

template<typename F>  //模板类型,可以接受任意可调用物;
LHCTimer::LHCTimer( boost::asio::io_service &ios, int second, int countMax, F func )
	:Fun(func)
	,Seconds(second)
	,Count_Max(countMax)
	,D_Timer(ios, boost::posix_time::seconds(second)) //启动计时器;
{
	Count = 1;
	
	D_Timer.async_wait( boost::bind(&LHCTimer::CallFunc, this, boost::asio::placeholders::error) ); //异步等待计时器，注册回调函数;
}

#endif // LHCTimer_h__

②main.cpp

#include <boost/ref.hpp>

#include "LHCTimer.h"

//TCP客户端-同步;
void TCPClient( boost::asio::io_service &ios, boost::asio::ip::tcp::endpoint &ep )
{
	try
	{
		std::cout << "client start." << std::endl;

		boost::asio::ip::tcp::socket sock( ios );
		sock.connect( ep );

		//发送数据;
		sock.write_some( boost::asio::buffer( "Hello Server!" ) );

		//接收数据;
		std::vector<char> str( 100, 0 );
		sock.read_some( boost::asio::buffer(str) );

		//输出至控制台;
		std::cout << "Recive from " << sock.remote_endpoint().address() << std::endl;
		std::cout << "Mes: " << &str[0] << std::endl;
	}
	catch ( boost::system::system_error &e )
	{
		std::cout << "process failed : " << e.what() << std::endl;
	}
}

int main( int argc, char * argv[] )
{
	//TCP客户端-同步;
	// 在同步模式下，程序发起一个IO操作，向io_service提交请求，io_service把操作转交给操作系统，同步地等待;
	// 当IO操作完成时，操作系统通知io_service，然后io_service再把结果发回给程序，完成整个同步流程;
	// 这个处理流程与多线程join()等待方式很相似【死等】;
	{
		boost::asio::io_service ios;
		boost::asio::ip::tcp::endpoint ep( boost::asio::ip::address::from_string("127.0.0.1"), 6688 );

		//创建计时器，每隔2秒，执行TCPClient函数，执行5次;
		LHCTimer timer( ios, 2, 5, boost::bind(TCPClient, boost::ref(ios), boost::ref(ep)) );

		//调用io_service的run()成员函数可以等待异步操作完成;
		//当前run()用于等待LHCTimer计时器的异步操作，而非TCPClient绑定函数;
		ios.run();       //很重要，异步IO必须;她启动前摄器的时间处理循环,阻塞等待所有的操作完成并分派事件;
						 //如果不调用run() 那么虽然操作被异步执行了，但没有一个等待它完成的机制，回调函数得不到执行机会;
	}

	system( "pause" );
	return 0;
}