void tTVPAsyncImageLoader::LoadingThread() {
while( !GetTerminated() ) {
// キュー追加イベント待ち
PushCommandQueueEvent.WaitFor(0);
if( GetTerminated() ) break;
bool loading;
do {
loading = false;
tTVPImageLoadCommand* cmd = NULL;
{ // Lock
tTJSCriticalSectionHolder cs(CommandQueueCS);
if( CommandQueue.size() ) {
cmd = CommandQueue.front();
CommandQueue.pop();
}
}
if( cmd ) {
loading = true;
LoadImageFromCommand(cmd);
{ // Lock
tTJSCriticalSectionHolder cs(ImageQueueCS);
LoadedQueue.push(cmd);
}
// Send to message
SendToLoadFinish();
}
} while( loading && !GetTerminated() );
}
}
void XLog::Run()
{
while (!GetTerminated())
{
sleep((unsigned int)(m_flush_interval / 1000));
if (GetTerminated())
break;
SwitchQueue();
}
}
void CMemcacheConnCheckThread::Execute()
{
while( !GetTerminated() )
{
CheckMemcacheConnection();
//休眠3s
Delay(3000000);
}
}
//---------------------------------------------------------------------------
void tTVPWatchThread::Execute()
{
while(!GetTerminated())
{
TVPCheckTickOverflow();
Event.WaitFor(0x10000000);
// 0x10000000 will be enough to watch timeGetTime()'s counter overflow.
}
}
//线程入口函数
void CFrameMainThread::Execute()
{
bool bHasData = false;
//int32_t nThreadID = (int32_t)gettid();
//g_FrameThreadMgt.RegistThread(nThreadID, this);
Delay(enmThreadExecutePeriod * 10);
WRITE_MAIN_LOG(enmLogLevel_Debug, "MainThread Start!\n");
bool bIdle = true;
while ((!GetTerminated()) || (!bIdle))
{
bIdle = true;
//处理定时器事件
bHasData = ProcessTimerEvent();
if (bHasData)
{
bIdle = false;
}
//处理CS通信数据
if (bIdle)
{
bHasData = ProcessCSLogicData();
if (bHasData)
{
bIdle = false;
}
}
if (bIdle)
{
bHasData = g_FrameNetThread.Execute();
if (bHasData)
{
bIdle = false;
}
}
//若没有任务需要处理
if (bIdle)
{
//写入统计数据
//GET_NETTHREADSTAT_INSTANCE().WriteCount();
Delay(enmThreadExecutePeriod);
}
}
WRITE_MAIN_LOG(enmLogLevel_Debug, "MainThread Stop!\n");
}
void CHandlerWorkerThread::Execute()
{
while (!GetTerminated())
{
try
{
m_Handler.m_bThreadNeedSleep = true;
m_Handler.Handle();
}
catch (CException& e)
{
m_Handler.m_bThreadNeedSleep = true;
Logger.Write(e);
}
if (m_Handler.m_bThreadNeedSleep)
this->Sleep(m_Handler.m_fThreadSleepSeconds);
}
}
//---------------------------------------------------------------------------
//void __fastcall tTVPTimerThread::UtilWndProc(Messages::TMessage &Msg)
void tTVPTimerThread::Proc( NativeEvent& ev )
{
// Window procedure of UtilWindow
if( ev.Message == TVP_EV_TIMER_THREAD && !GetTerminated())
{
// pending events occur
tTJSCriticalSectionHolder holder(TVPTimerCS); // protect the object
std::vector<tTJSNI_Timer *>::iterator i;
for(i = Pending.begin(); i!=Pending.end(); i ++)
{
tTJSNI_Timer * item = *i;
item->FirePendingEventsAndClear();
}
Pending.clear();
PendingEventsAvailable = false;
}
else
{
EventQueue.HandlerDefault(ev);
}
}
//---------------------------------------------------------------------------
void tTVPTimerThread::Execute()
{
while(!GetTerminated())
{
tjs_uint64 step_next = (tjs_uint64)(tjs_int64)-1L; // invalid value
tjs_uint64 curtick = TVPGetTickCount() << TVP_SUBMILLI_FRAC_BITS;
DWORD sleeptime;
{ // thread-protected
tTJSCriticalSectionHolder holder(TVPTimerCS);
bool any_triggered = false;
std::vector<tTJSNI_Timer*>::iterator i;
for(i = List.begin(); i!=List.end(); i ++)
{
tTJSNI_Timer * item = *i;
if(!item->GetEnabled() || item->GetInterval() == 0) continue;
if(item->GetNextTick() < curtick)
{
tjs_uint n = static_cast<tjs_uint>( (curtick - item->GetNextTick()) / item->GetInterval() );
n++;
if(n > 40)
{
// too large amount of event at once; discard rest
item->Trigger(1);
any_triggered = true;
item->SetNextTick(curtick + item->GetInterval());
}
else
{
item->Trigger(n);
any_triggered = true;
item->SetNextTick(item->GetNextTick() +
n * item->GetInterval());
}
}
tjs_uint64 to_next = item->GetNextTick() - curtick;
if(step_next == (tjs_uint64)(tjs_int64)-1L)
{
step_next = to_next;
}
else
{
if(step_next > to_next) step_next = to_next;
}
}
if(step_next != (tjs_uint64)(tjs_int64)-1L)
{
// too large step_next must be diminished to size of DWORD.
if(step_next >= 0x80000000)
sleeptime = 0x7fffffff; // smaller value than step_next is OK
else
sleeptime = static_cast<DWORD>( step_next );
}
else
{
sleeptime = INFINITE;
}
if(List.size() == 0) sleeptime = INFINITE;
if(any_triggered)
{
// triggered; post notification message to the UtilWindow
if(!PendingEventsAvailable)
{
PendingEventsAvailable = true;
EventQueue.PostEvent( NativeEvent(TVP_EV_TIMER_THREAD) );
}
}
} // end-of-thread-protected
// now, sleeptime has sub-milliseconds precision but we need millisecond
// precision time.
if(sleeptime != INFINITE)
sleeptime = (sleeptime >> TVP_SUBMILLI_FRAC_BITS) +
(sleeptime & ((1<<TVP_SUBMILLI_FRAC_BITS)-1) ? 1: 0); // round up
// clamp to TVP_LEAST_TIMER_INTERVAL ...
if(sleeptime != INFINITE && sleeptime < TVP_LEAST_TIMER_INTERVAL)
sleeptime = TVP_LEAST_TIMER_INTERVAL;
Event.WaitFor(sleeptime); // wait until sleeptime is elapsed or
// Event->SetEvent() is executed.
}
}
