asynDBCenter
asynDBCenter是GS和DBCenter之间的模块，有了他GS访问数据库就是异步的了，以前是同步的，加入某个操作很耗时那么GS就在那等待这个返回值。
.对于std::queue哪些情况要加锁，哪些不加
push、pop操作100%必须加锁，front和back操作是只读的，不会破坏状态，但是有读写顺序要求时还是要同步。
一般empty和size就不要锁了，对于锁 里面有两个容器
std::queue<CmdPkt> m_queueCmdPkt;//命令包容器
std::queue<HrPkt> m_queueHrPkt;//相应包容器 .m_queueCmdPkt这个容器是什么时候放入的呢？
玩家登录获取userid的函数
/*
std::condition_variable
进入时获得锁，wait时释放，当别人通知的时候重新获得
锁的状态在线程阻塞之前和阻塞之后相同
*/
void asynDBCenter::push_cmd(CmdPkt pkt)
{
{
std::unique_lock<std::mutex> cond_lock(m_cond_mtx);//这里加锁，主要还是同步，但没有多大意义，因为没有对公共的变量操作，不是很确定
{
std::unique_lock<std::mutex> cmd_lock(m_cmd_mtx);
m_queueCmdPkt.push(pkt);
}
}
m_cond.notify_one();//取的线程阻塞了，现在通知
} void asynDBCenter::getUserID(std::function<void(int hr)>* on_getUserID, char* userName)
{
boost::property_tree::ptree pt;
pt.put("userName", userName);
std::stringstream os;
boost::property_tree::write_json(os, pt); CmdPkt pkt;
pkt.json = os.str();
pkt.process = std::bind(&asynDBCenter::isGetUserID, this, ph::_1, ph::_2);
pkt.on_process = (void*)on_getUserID;
push_cmd(pkt);//此时放入
} .什么时候从m_queueCmdPkt容器获取
asynDBCenter::asynDBCenter()
{
m_dbcenter.reset(NEW(DBCenter));
m_spThread.reset(new std::thread(std::bind(&asynDBCenter::threadLoop, this)));
} bool asynDBCenter::get_front_and_pop(CmdPkt& pkt)
{
//对于这句不放到锁里面，我在想如果执行这句不为空，然后执行到下面的时候别的线程把他变成空了，岂不是错了
//但我看也就只有这一个对方在取，所以不放到锁里面也是可以的
if(m_queueCmdPkt.empty())
return false;
{
std::unique_lock<std::mutex> lock(m_cmd_mtx);
pkt = m_queueCmdPkt.front();
m_queueCmdPkt.pop();
}
return true;
} void asynDBCenter::threadLoop()
{
while()
{
CmdPkt pkt;
if(get_front_and_pop(pkt))
{
pkt.process(pkt.on_process, pkt.json.c_str());//访问数据库
continue;
}
{//表示GS发过来的命令没有了
std::unique_lock<std::mutex> cond_lock(m_cond_mtx);
m_cond.wait(cond_lock);//使用unique_lock锁住当前线程，然后另一个线程在相同的m_cond上调用notify时此线程才会解除阻塞
}
}
} .访问数据库 void asynDBCenter::push_hr(HrPkt pkt)
{
std::unique_lock<std::mutex> hr_lock(m_hr_mtx);
m_queueHrPkt.push(pkt);//直接放入
} void asynDBCenter::isGetUserID(void* on_process, const char* arg)
{
std::stringstream ros(arg);
boost::property_tree::ptree pt;
boost::property_tree::read_json(ros, pt);
std::string userName = pt.get<std::string>("userName"); int ret = m_dbcenter->getUserID(const_cast<char*>(userName.c_str())); boost::property_tree::ptree ret_pt;//将数据库返回的值封装成json
ret_pt.put("userID", ret);
std::stringstream wos;
boost::property_tree::write_json(wos, ret_pt);
//放到结果包里面去
HrPkt pkt;
pkt.hr = wos.str();
pkt.on_process = on_process;
pkt.process = std::bind(&asynDBCenter::onGetUserID, this, ph::_1, ph::_2);
push_hr(pkt);
} .函数回调
void asynDBCenter::drive()
{ HrPkt pkt;
for (;;)
{
if(!m_queueHrPkt.size())//drive一下就把m_queueHrPkt所有的命令都执行了
break ;
{
std::unique_lock<std::mutex> hr_lock(m_hr_mtx);
pkt = m_queueHrPkt.front();
m_queueHrPkt.pop();
}
pkt.process(pkt.on_process, pkt.hr.c_str(), pkt.len);
}
} for (;;)
{
procMapSendData();//test1 m_asyndb->drive();//这个是在gs里面drive的 bool hr = process_loop(pkt);
procMapSendData();
//......
}
GS线程发命令到asyn,asyn线程去访问数据库，然后GS线程去驱动，然后回调GS里面的函数
function在这里面起了很大的作用