UINT CThread::ThreadProc(LPVOID pObject)
{
ASSERT(pObject);
ASSERT_KINDOF(CThread, (CObject *)pObject);
CThread *pThread = (CThread *)pObject;
// initialisieren, ausführen, aufräumen
if (pThread->InitInstance())
pThread->Run();
UINT nResult = pThread->ExitInstance();
// den tatsächlich gelieferten Exit-Code setzen
pThread->SetExitCode(nResult);
pThread->m_pWinThread = NULL; // zerstört sich selbst
HANDLE hThreadStoppedEvent = pThread->m_hThreadStoppedEvent;
// Thread-Objekt ggf. automatisch zerstören
if (pThread->m_bAutoDelete) delete pThread;
// Beendigungs-Event setzen; setzt alle Threads fort, die in Join() warten
VERIFY(SetEvent(hThreadStoppedEvent));
return nResult;
}
unsigned __stdcall ThreadProcess(void *pThreadPtr )
{
CThread *pThread = (CThread*)pThreadPtr;
pThread->Run();
pThread->Exit();
return 0;
}
//*********************************************************
//creates the thread
//*********************************************************
int CThread::runProcess (void* Param)
{
CThread* thread;
thread = (CThread*)((param*)Param)->pThread;
delete ((param*)Param);
return thread->Process (0);
}
DWORD CThread::run(LPVOID thread)
{
CThread* Thread = ((CThread*)thread);
Thread->m_Func(Thread->m_Param);
SetEvent(Thread->m_Exit);
return NULL;
}
unsigned int WINAPI ThreadProc(LPVOID lpParam)
{
CThread * p = (CThread *) lpParam;
p->Run();
_endthreadex(0);
return 0;
}
static THREAD_FUN __stdcall ThreadProc(LPVOID lpParam) {
CThread * pThis = (CThread *)lpParam;
TASSERT(pThis, "a null thread owner point");
pThis->Run();
_endthreadex(0);
return 0;
}
void CBackgroundInfoLoader::Load(CFileItemList& items)
{
StopThread();
if (items.Size() == 0)
return;
CSingleLock lock(m_lock);
for (int nItem=0; nItem < items.Size(); nItem++)
m_vecItems.push_back(items[nItem]);
m_pVecItems = &items;
m_bStop = false;
m_bStartCalled = false;
int nThreads = m_nRequestedThreads;
if (nThreads == -1)
nThreads = (m_vecItems.size() / (ITEMS_PER_THREAD+1)) + 1;
if (nThreads > g_advancedSettings.m_bgInfoLoaderMaxThreads)
nThreads = g_advancedSettings.m_bgInfoLoaderMaxThreads;
m_nActiveThreads = nThreads;
for (int i=0; i < nThreads; i++)
{
CThread *pThread = new CThread(this, "Background Loader");
pThread->Create();
#ifndef _LINUX
pThread->SetPriority(THREAD_PRIORITY_BELOW_NORMAL);
#endif
m_workers.push_back(pThread);
}
}
qboolean G_ClientRunThreadCmd( const gentity_t *ent )
{
str threadName;
CThread *thread;
Q_UNUSED(ent);
// Get the thread name
if ( !gi.argc() )
return true;
threadName = gi.argv( 1 );
// Check to make sure player is allowed to run this thread
// Need to do this part
// Run the thread
if ( !threadName.length() )
return true;
thread = Director.CreateThread( threadName );
if ( thread )
thread->DelayedStart( 0.0f );
return true;
}
///////////////////////////////////////////////////////////////////////////
// function : start the thread's run() virtual function
unsigned long __stdcall CThread::ThreadFunction( void *pV )
{
int result = 0;
CThread* pThis = (CThread*)pV;
if (pThis)
{
CWinSeh::ResetSeh();
try{
result = pThis->Run();
} // End of try
catch( std::exception &ex )
{
std::cout << "Cpp Exception : " << ex.what() << std::endl;
}
catch( CWinSeh &ex )
{
std::cout << "System Exception : " << ex.GetExpCode() << " : " << ex.GetExpDes( ) << std::endl;
}
catch(...){
std::cout << "Get an unknown exception!" << std::endl;
} // End of catch( ... )
} // end of if
return result;
}
int CServerLinker::Monitor(void)
{
CServerLinkerMonitor *pMonitor = NULL;
pMonitor = new(std::nothrow) CServerLinkerMonitor();
if (NULL == pMonitor)
{
Q_Printf("%s", Q_EXCEPTION_ALLOCMEMORY);
return Q_ERROR_ALLOCMEMORY;
}
pMonitor->setServerLinker(this);
try
{
CThread objThread;
//等待线程启动
m_objMutex.Lock();
objThread.Execute(pMonitor);
m_objCond.Wait(&m_objMutex, 1000);
m_objMutex.unLock();
}
catch (CException &e)
{
Q_SafeDelete(pMonitor);
Q_Printf("exception code %d message %s", e.getErrorCode(), e.getErrorMsg());
return e.getErrorCode();
}
return Q_RTN_OK;
}
DWORD WINAPI
#else
LPVOID
#endif
_THKERNEL( LPVOID lpvData /* CThread Object */
)
{
CThread *pThread = (CThread *)lpvData;
ThreadType_t lastType;
/*
*
* initialization
*
*/
pThread->m_mutex.Lock();
pThread->m_state = ThreadStateWaiting;
pThread->m_bRunning = TRUE;
#ifndef WINDOWS
pThread->m_dwId = CThread::ThreadId();
#endif
pThread->m_mutex.Unlock();
while( TRUE )
{
lastType = pThread->m_type;
if( lastType == ThreadTypeEventDriven )
{
if( ! pThread->m_event.Wait() )
break;
}
if( ! pThread->KernelProcess() )
break;
if( lastType == ThreadTypeEventDriven )
pThread->m_event.Reset();
if( pThread->m_type == ThreadTypeIntervalDriven )
Sleep(pThread->m_dwIdle);
}
pThread->m_mutex.Lock();
pThread->m_state = ThreadStateDown;
pThread->m_bRunning = FALSE;
pThread->m_mutex.Unlock();
#ifdef WINDOWS
return 0;
#else
return (LPVOID)0;
#endif
}
//static method
static void* runProcess (void* pThis)
{
workAround* wA = (workAround*)pThis;
//this will call the appropriate method, as Process is a virtual method
CThread* thread = wA->this_thread;
delete wA;
thread->run();
}
void* CThread::ThreadFunction(void* args)
{
CThread* thread = reinterpret_cast<CThread*>(args);
thread->Process();
thread->m_running = false;
return NULL;
}
DWORD WINAPI CThread::ThreadProc(LPVOID lpParameter)
{
CThread *pThread = (CThread *)lpParameter;
if(pThread)
return pThread->Execute();
else
return (DWORD)-1;
}
void* CThread::helper(void* arg)
{
CThread* p = (CThread*)arg;
p->entry();
return NULL;
}
DWORD CThread::helper(LPVOID arg)
{
CThread* p = (CThread*)arg;
p->entry();
return 0UL;
}
void* CThread::Hook(void* args)
{
CThread* thread = (CThread*) args;
if (thread->runnuble()) {
thread->runnuble()->Run(thread, thread->args());
}
return (void*)NULL;
}
//=============================================================================
static DWORD WINAPI ThreadEntryPoint (LPVOID param)
{
CThread * thread = (CThread *)param;
ASSERT(thread);
thread->ThreadEnter();
return 0;
}
THREAD_FUN CThread::__WorkThread(void *arg)
{
CThread *pThis = (CThread*) arg;
#ifdef WIN32
return pThis->DoRunning();
#else
pThis->DoRunning();
#endif
}
void CWorker::WaitForObject() {
CTrace::CEnter Enter(CTrace::Layer::CODINE, L"Worker::WaitForObject()");
for (list<CThread*>::iterator it = m_ThreadList.begin(); it != m_ThreadList.end(); it++) {
CThread *TheThread;
TheThread = *it;
TheThread->WaitForObject();
}
}
void CThread::Create(THREAD_EXEC_PROC pExecProc, void *pParam)
{
CThread *pThread = new CThread();
pThread->SetFreeOnTerminate(true);
pThread->m_pExecProc = pExecProc;
pThread->m_pThreadParam = pParam;
pThread->Run();
}
void *CThread::ThreadProc(void *obj)
{
CThread *pThread = static_cast<CThread*>(obj);
int canc = vlc_savecancel ();
pThread->Execute();
vlc_restorecancel (canc);
return NULL;
}
void CThread::startup(void* P)
{
CThread* T = (CThread*)P;
if (T->thMessages) clMsg("* THREAD #%d: Started.",T->thID);
FPU::m64r ();
T->Execute ();
T->thCompleted = TRUE;
if (T->thMessages) clMsg("* THREAD #%d: Task Completed.",T->thID);
}
CThread * GameLauncher::loadGameToMemoryAsync(const discHeader *header, sigslot::signal2<const discHeader *, int> * asyncLoadFinished)
{
asynch_params_t *params = new asynch_params_t;
params->hdr = header;
params->asyncLoadFinished = asyncLoadFinished;
CThread * thread = CThread::create(gameLoadCallback, (void*)params, CThread::eAttributeAffCore1);
thread->resumeThread();
return thread;
}
/*
==============
Start
Does all post-spawning setup. This is NOT called for savegames.
==============
*/
void Level::Start( void )
{
CThread *gamescript;
// initialize secrets
levelVars.SetVariable( "total_secrets", total_secrets );
levelVars.SetVariable( "found_secrets", found_secrets );
levelVars.SetVariable( "total_specialItems" , total_specialItems );
levelVars.SetVariable( "found_specialItems" , found_specialItems );
levelVars.SetVariable( "total_enemies_spawned", _totalEnemiesSpawned );
FindTeams();
// call the precache scripts
Precache();
// start executing the game script
if ( game_script.length() )
{
gi.ProcessLoadingScreen( "$$LoadingScript$$" );
program.Load( game_script );
gi.ProcessLoadingScreen( "$$DoneLoadingScript$$" );
// Create the main thread
gamescript = Director.CreateThread( "main" );
if ( gamescript )
{
// Run the precache thread if it exists
if ( gamescript->labelExists( "precache" ) )
{
CThread *precache_script;
precache_script = Director.CreateThread( "precache" );
if ( precache_script )
precache_script->DelayedStart( 0.0f );
}
// Run the main thread
gamescript->DelayedStart( 0.0f );
}
}
loadLevelStrings();
started = true;
}
/*static */
void* CThread::EntryPoint(void * pthis)
{
if(!pthis) return 0;
CThread * pt = (CThread*)pthis;
#if defined(USE_GMEMORYMANGER)
s3eMemorySetUserMemMgr(&pt->mgr);
#endif
pt->Run( pt->Arg() );
return 0;
}
unsigned __stdcall CThread::ThreadFun(void* params)
{
CThread* pThread = (CThread* )params;
if(NULL != pThread)
{
pThread->SetState(enumTHREADS_EXECUTING);
pThread->Run();
pThread->SetState(enumTHREADS_FINISHED);
}
return 0;
}
//hlavni procedura vlakna
DWORD WINAPI CThread::ThreadProc(void * x)
{
CThread* myThread = (CThread*) x;
// pomoci myThread lze jiz pristupovat i k nestatickym clenum tridy
myThread->Start(); // dynamicky volana metoda Start()
// po jejim vykonani je
// prace vlakna ukoncena
return (myThread->threadID); // opustenim ThreadProc zanika
// pracovni vlakno objektu CThread
};
void
#else
DWORD WINAPI
#endif
CThreadPool::ThreadEntry(void* lpParam)
{
//Rout call into instance.
CThread* pInstance = (CThread*) lpParam;
pInstance->ThreadFct();
return 0;
}
unsigned int CThread::ThreadProc( void* pArgs)
{
CThread* pthread = (CThread*)pArgs;
pthread->Run(NULL);
//<By Jackie 2013-6-8>的线程类, 是在heap上申请的, 我们在这里delete掉.
// 如果声明为局部变量, 那么就会出现提前析构的情况.
delete pthread;
return 0;
}
