游戏服务器之线程池管理器

连接线程管理器

template <typename T>
class connection_thread_manager : public base_manager<index_uint32,index_null<2>,index_null<3>,true>

{

...

//线程池管理器的初始化根据配置来启动线程数

bool init(const int min=1,const int max=1,const std::string name="thread",void *param=NULL)
{
setMinCount(min);
setMaxCount(max);
bool bret=true;
rwlock.wrlock();
for(int i = 0; i < getMaxCount(); i++)
{
T *thread = new T();
if(thread)
{
thread->initParam(param);
if (i < getMinCount() && !thread->start())
{
SAFE_DELETE(thread);
bret=false;
break;
}
if(!add_object(thread))
{
SAFE_DELETE(thread);
bret=false;
break;
}
}
else
{
bret=false;
break;
}
}
rwlock.unlock();
return bret;
}

}

/**
 * \description 得到本线程组总共的任务个数
 * \return 任务个数
 */
int taskCount()
{
struct GetBest:public callback<T>
{
int _size;
GetBest():_size(0){}
bool invoke(T *t)
{
_size += t->taskSize();
return true;
}
};
GetBest exec;
rwlock.rdlock();
invoke_all<T>(exec);
rwlock.unlock();
return exec._size;
}
/**
 * \description 回收所有线程
*/
void final()
{
struct RemoveAll : public temp_remove<T>
{
bool isIt(T *entry)
{
if(entry)
{
entry->final();
entry->join();
}
return true;
}
};
rwlock.wrlock();
RemoveAll exec;
condition_remove<T>(exec); 
rwlock.unlock();
}

/**
 * \description 回调每个线程
 * \param exec 执行接口
 */
template <class object>
bool traverse(callback<object> &exec)
{
rwlock.rdlock();
bool ret=invoke_all<>(exec);
rwlock.unlock();
return ret;
}
/**
 * \author cjy
* \description 添加一个线程
* \param entry 线程
* \return 添加是否成功
*/
bool addThread(connection_thread *entry)
{
bool bret = false;
rwlock.wrlock();
bret = add_object(entry);
rwlock.unlock();
return bret;
}
/**
* \author cjy
* \description 删除一个线程
* \param entry 线程
*/
void removeThread(connection_thread *entry)
{
rwlock.wrlock();
remove_object(entry);
rwlock.unlock();
}


/**
* \description 通过线程id查找线程执行体
* \param id 线程id
* \return 线程执行体,找不到返回NULL
*/
T *getThreadByID(const uint16 &id)
{
T *ret=NULL;
rwlock.rdlock();
ret= (T *)get_object_by_id(id);
rwlock.unlock();
return ret;
}

}

被动连接线程池：

验证、同步、网络收发、回收   线程，  分别各是线程连接管理器，会初始化和启动指定的线程

bool tcp_session_pool::init()
{
//创建回收线程
if(!recycleThreads.init(1,1,"recycle_thread",this))
{
g_log->debug("recycle_thread线程启动失败");
return false;
}
//创建初始化验证线程
if(!verifyThreads.init(1,2,"verify_thread",this))
{
g_log->debug("verify_thread线程启动失败");
return false;
}
//创建初始化同步线程
if(!syncThreads.init(1,1,"sync_thread",this))
{
g_log->debug("sync_thread线程启动失败");
return false;
}
//创建初始主线程（每512个连接会增加一个线程,最大连接数是配置的）
int maxThreadCount = (maxConns + main_service_thread::getMaxSize() - 1)/main_service_thread::getMaxSize();
g_log->debug("线程最大连接数%d,每线程连接数%d,线程个数%d",maxConns,main_service_thread::getMaxSize(),maxThreadCount);
if(!okayThreads.init(1,maxThreadCount,"main_service_thread",this))
{
g_log->debug("main_service_thread线程启动失败");
return false;
}
return true;
}

主动连接线程池：

连接测试、验证、网络收发线程初始化和启动

bool tcp_client_pool::init(const uint32 perThreadSize)
{
if (!checkconnectThread.init(1, 1, "checkconnectThread",this))//测试连接线程
{
return false;
}
if (!checkwaitThread.init(1, 1, "checkwaitThread",this))//验证线程
{
return false;
}
main_client_thread::settMaxSize(perThreadSize);//网络收发线程
int maxThreadCount = (maxConns + main_client_thread::getMaxSize() -1)/main_client_thread::getMaxSize();
if (!clienttaskThread.init(1, maxThreadCount, "clienttaskThread",this))
{
return false;
}
return true;
}