gflags用法与boost异步I/O服务经典示例

（第一次从项目中接触这类知识，还是挺好奇，于是自己写了一段）

gflags是google的一套开源命令行参数解析工具，在工程化的开发当中经常用到，其安装可以参考网上，下面仅演示gflags的参数定义、参数检查、参数传入。

boost是是一个可移植、提供源代码的C++库，作为标准库的后备，是C++标准化进程的开发引擎之一。c++标准一直都在变，现在c++11用得比较多，但以前的工程里一直还是习惯使用boost，所以要看懂以前的代码，boost还是要看一下的，下面演示了boost异步服务，通过定时器实现定时输出功能，并实现了类之间的回调。

#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include "gflags/gflags.h"
#include <iostream>


static int second = 0;
boost::shared_mutex myMutex;
//定义等待时间
DEFINE_int32(timer_wait_second,2,"wait time in seconds");

class myClass
{
public:
	myClass() :myAge(20), myName("alpc40") {}
	bool setAgeName(const int age, const std::string name) {
		myAge = age;
		myName = name;
		return true;
	}
	void outAgeName() {
		std::cout << myAge << " " << myName <<std::endl;
	}

private:
	int myAge;
	std::string myName;
};


class cls
{
	//定义回调形式，与myClass相关
	using callBack = std::function<bool(const int, const std::string)>;
	using printCallBack = std::function<void(void)>;
public:
	cls();
	~cls();
	void print(const boost::system::error_code &ec);
	void RegisteUserCallBack(callBack call_back);
	void RegistePrintCallBack(printCallBack call_back);
private:
	boost::asio::io_service io_service;
	boost::asio::deadline_timer timer;
	boost::thread* thread;
	callBack my_call_back;
	printCallBack my_print_call_back;
};
//回调函数
void cls::RegistePrintCallBack(printCallBack call_back)
{
	my_print_call_back = call_back;
}
//回调函数
void cls::RegisteUserCallBack(callBack call_back)
{
	my_call_back = call_back;
}

cls::cls() : timer(io_service, boost::posix_time::seconds(FLAGS_timer_wait_second)) {
	//timer绑定函数，即当timer结束后，才启动该函数
	timer.async_wait(boost::bind(&cls::print, this, boost::asio::placeholders::error));
	thread = new boost::thread([&] {
		//io_service开始工作，这个时候timer才开始启动
		boost::asio::io_service::work work(io_service);
		//异步阻塞，直到work完成才能结束
		io_service.run();
	});
}

cls::~cls() {
	//释放时先取消定时器
	timer.cancel();
	//取消异步IO服务
	io_service.stop();
	//取消线程
	if (thread != nullptr) {
		//线程阻塞,直到thread运行完毕
		thread->join();
		delete thread;
		thread = nullptr;
	}
}

void cls::print(const boost::system::error_code &ec)
{
	printf("%d s\n", ++second);
	//使用锁，写myClass类
	boost::unique_lock<boost::shared_mutex> _(myMutex);
	my_call_back(second, "haha");
	my_print_call_back();
	if (second < 8)
	{
		//使timer重新激发，继续运行
		timer.expires_from_now(boost::posix_time::seconds(FLAGS_timer_wait_second));
		timer.async_wait(boost::bind(&cls::print, this, boost::asio::placeholders::error));
	}
	
}
//参数赋值检测函数，使1<FLAGS_timer_wait_second< 60
static bool validateTimer(const char *name, int32_t second)
{
	if (second > 60 || second < 1)
		return false;
	return true;
}

int main(int argc,char **argv)
{
	//注册参数赋值检测函数
	gflags::RegisterFlagValidator(&FLAGS_timer_wait_second, &validateTimer);
	//参数来自输入，自行赋值给FLAGS
	gflags::ParseCommandLineFlags(&argc, &argv, true);
	//定义两个类
	myClass heihei;
	cls haha;
	//注册函数，也就是说，在haha类当中可以调用heihei类，使heihei类进行改变
	haha.RegisteUserCallBack(std::bind(&myClass::setAgeName, &heihei, std::placeholders::_1, std::placeholders::_2));
	haha.RegistePrintCallBack(std::bind(&myClass::outAgeName, &heihei));
	while (1)
	{
		Sleep(1000);
		//获得主线程ID
		std::cout << boost::this_thread::get_id() << ":";
		//获得锁，防止输出时输入
		boost::unique_lock<boost::shared_mutex> _(myMutex);
		heihei.outAgeName();
	}
	return 0;
}

可以运行下，看看效果与自己的期望是不是一样，还是挺有意思的