void ServerThread::run( )
{
g_pLog->log_debug("%u,%u,ServerThread::run(),ThreadID %d",0,0,getTID());
g_pServerManager->m_ThreadID = getTID( );
while(IsActive() )
{
if(g_pServerManager)
{
MySleep(100);
bool ret = g_pServerManager->Tick( );
Assert( ret );
}
}
}
VOID LoginDBManager::run()
{
__ENTER_FUNCTION
printf("run db Thread \r\n");
UINT uTime = g_pTimeManager->CurrentTime();
g_DBLogicManager.m_ThreadID = getTID();
while (IsActive())
{
MySleep(100);
if(!mCharDBInterface->IsConnected())
{
BOOL bRet = mCharDBInterface->Connect();
if(!bRet)
{
Log::SaveLog("./Log/Login.log","mCharDBInterface->Connect() Get Errors: %s",mCharDBInterface->GetErrorMsg());
MySleep(5000);//保证不频繁连接数据库
}
else
Log::SaveLog("./Log/Login.log","Reconnect database");
}
g_DBLogicManager.HeartBeat(uTime);
}
printf("end db Thread \r\n");
__LEAVE_FUNCTION
}
unsigned int* ThreadLocalRand::getSeed() {
unsigned int* p = seed_.get(false /*createLocal*/);
if (!p) { // init seed
if (FLAGS_thread_local_rand_use_global_seed) {
p = new unsigned int(defaultSeed_);
} else if (getpid() == getTID()) { // main thread
// deterministic, but differs from global srand()
p = new unsigned int(defaultSeed_ - 1);
} else {
p = new unsigned int(defaultSeed_ + getTID());
VLOG(3) << "thread use undeterministic rand seed:" << *p;
}
seed_.set(p);
}
return p;
}
std::default_random_engine& ThreadLocalRandomEngine::get() {
auto engine = engine_.get(false);
if (!engine) {
engine = new std::default_random_engine;
int defaultSeed = ThreadLocalRand::getDefaultSeed();
engine->seed(FLAGS_thread_local_rand_use_global_seed
? defaultSeed
: defaultSeed + getTID());
engine_.set(engine);
}
return *engine;
}
StatInfo::~StatInfo() {
if (stat_) {
std::lock_guard<std::mutex> guard(stat_->lock_);
if (stat_->destructStat_.max_ < this->max_) {
stat_->destructStat_.max_ = this->max_;
}
if (stat_->destructStat_.min_ > this->min_) {
stat_->destructStat_.min_ = this->min_;
}
stat_->destructStat_.total_ += this->total_;
stat_->destructStat_.count_ += this->count_;
stat_->threadLocalBuf_.remove({this, getTID()});
}
}
void Stat::addSample(uint64_t value) {
StatInfo* statInfo = statInfo_.get(false);
if (!statInfo) {
statInfo = new StatInfo(this);
statInfo_.set(statInfo);
std::lock_guard<std::mutex> guard(lock_);
threadLocalBuf_.push_back({statInfo, getTID()});
}
if (value > statInfo->max_) {
statInfo->max_ = value;
}
if (value < statInfo->min_) {
statInfo->min_ = value;
}
statInfo->total_ += value;
statInfo->count_++;
}
VOID SceneThread::run()
{
__ENTER_FUNCTION
INT i ;
TID cTid = getTID() ;
for ( i = 0; i < m_nSceneCount; i++ )
{
m_apScene[i]->m_ThreadID = cTid ;
}
if ( 0 == m_nSceneCount )
{
Log::SaveLog( SERVER_LOGFILE, "SceneThread:: no scene add! TID: %d", cTid ) ;
return ;
}
_MY_TRY
{
for ( i = 0; i < m_nSceneCount; i++ )
{
Log::SaveLog( SERVER_LOGFILE, "SceneThread::run() TID: %d SID: %d SName: %s...",
cTid, m_apScene[i]->SceneID(), g_pSceneManager->GetSceneInfo( m_apScene[i]->SceneID() )->m_szName ) ;
}
while ( IsActive() )
{
for ( i = 0; i < m_nSceneCount; i++ )
{
BOOL ret = m_apScene[i]->Tick() ;
Assert( ret ) ;
}
}
}
_MY_CATCH
{
SaveCodeLog() ;
}
Quit() ;
__LEAVE_FUNCTION
}
BOOL DBThread::ProcessCacheCommand()
{
PlayerID_t PlayerID ;
_MY_TRY
{
BOOL ret = FALSE ;
Packet* pPacket = NULL ;
ret = RecvPacket( pPacket, PlayerID);
if( !ret )
return TRUE ;
Player* pPlayer = g_pPlayerPool->GetPlayer( PlayerID ) ;
if( pPlayer )
{
pPacket->Execute(pPlayer) ;
}
else
{
pPacket->Execute(NULL);
}
g_pPacketFactoryManager->RemovePacket( pPacket ) ;
return TRUE;
}
_MY_CATCH
{
g_pLog->FastSaveLog(LOG_FILE_0,"DBThread::ProcessCacheCommand Get Errors,TID=%d,PlayerID =%d",getTID(),PlayerID);
return TRUE;
}
}
