自学教程：C++ IsMainThread函数代码示例

int32_t RunJob(MainThreadRunner *runner, MainThreadJob *job){  JobEntry entry;  // initialize the entry  entry.runner = runner;  entry.pepper_instance = runner->pepper_instance_;  entry.job = job;  bool in_main_thread = IsMainThread();  // Must be off main thread, or on a pseudothread.  assert(!in_main_thread || in_pseudo_thread_);  // Thread type specific initialization.  if (in_main_thread) {    entry.pseudo_thread_job = true;  } else {    entry.pseudo_thread_job = false;    // Init condition variable.    entry.is_done = false;    int ret = pthread_mutex_init(&entry.done_mutex, NULL);    assert(!ret);    ret = pthread_cond_init(&entry.done_cond, NULL);    assert(!ret);  }  // put the job on the queue  pthread_mutex_lock(&(runner->lock_));  //job_queue_.push_back(&entry);  //JobEntry_list_push_back(&entry, &(runner->job_queue_));  runner->job_queue_[runner->qtail]=&entry;  runner->qtail = (runner->qtail+1)%QSIZE;  runner->size++;  pthread_mutex_unlock(&(runner->lock_));#ifdef USE_PEPPER  // Schedule the job.  //pp::Module::Get()->core()->CallOnMainThread(0,  //    pp::CompletionCallback(&DoWorkShim, this), PP_OK);  g_core_interface->CallOnMainThread(0,      PP_MakeCompletionCallback(&DoWorkShim, runner), PP_OK);#endif  // Block differntly on the main thread.  if (entry.pseudo_thread_job) {    // block pseudothread until job is done    PseudoThreadBlock();  } else {    // wait on condition until the job is done    pthread_mutex_lock(&entry.done_mutex);    while (!entry.is_done) {      pthread_cond_wait(&entry.done_cond, &entry.done_mutex);    }    pthread_mutex_unlock(&entry.done_mutex);    pthread_mutex_destroy(&entry.done_mutex);    pthread_cond_destroy(&entry.done_cond);  }  // Cleanup.  //delete job;  free(job);  return entry.result;}

void Ctrl::EventLoop(Ctrl *ctrl){	GuiLock __;	ASSERT_(IsMainThread(), "EventLoop can only run in the main thread");	ASSERT(LoopLevel == 0 || ctrl);	LoopLevel++;	LLOG("Entering event loop at level " << LoopLevel << LOG_BEGIN);	Ptr<Ctrl> ploop;	if(ctrl) {		ploop = LoopCtrl;		LoopCtrl = ctrl;		ctrl->inloop = true;	}	bool quit = false;	int64 loopno = ++EventLoopNo;	ProcessEvents(&quit);	while(loopno > EndSessionLoopNo && !quit && (ctrl ? ctrl->IsOpen() && ctrl->InLoop() : GetTopCtrls().GetCount()))	{//		LLOG(GetSysTime() << " % " << (unsigned)msecs() % 10000 << ": EventLoop / GuiSleep");		SyncCaret();		GuiSleep(1000);//		LLOG(GetSysTime() << " % " << (unsigned)msecs() % 10000 << ": EventLoop / ProcessEvents");		ProcessEvents(&quit);//		LLOG(GetSysTime() << " % " << (unsigned)msecs() % 10000 << ": EventLoop / after ProcessEvents");	}	if(ctrl)		LoopCtrl = ploop;	LoopLevel--;	LLOG(LOG_END << "Leaving event loop ");}

void Ctrl::GuiSleep0(int ms){	GuiLock __;	ASSERT(IsMainThread());	ELOG("GuiSleep");	if(EndSession())		return;	ELOG("GuiSleep 2");	int level = LeaveGuiMutexAll();#if !defined(flagDLL) && !defined(PLATFORM_WINCE)	if(!OverwatchThread) {		DWORD dummy;		OverwatchThread = CreateThread(NULL, 0x100000, Win32OverwatchThread, NULL, 0, &dummy);		ELOG("ExitLoopEventWait 1");		ExitLoopEvent().Wait();	}	HANDLE h[1];	*h = ExitLoopEvent().GetHandle();	ELOG("ExitLoopEventWait 2 " << (void *)*h);	MsgWaitForMultipleObjects(1, h, FALSE, ms, QS_ALLINPUT);#else	MsgWaitForMultipleObjects(0, NULL, FALSE, ms, QS_ALLINPUT);#endif	EnterGuiMutex(level);}

SpanRect::SpanRect(const Rect &inRect, int inAA){   mAA =  inAA;   mAAMask = ~(mAA-1);   mRect = inRect * inAA;   mWinding = 0xffffffff;   mTransitions = 0;      if (IsMainThread())   {      if (sTransitionsBuffer.size() < mRect.h)         sTransitionsBuffer.resize(mRect.h);      mTransitions = &sTransitionsBuffer[0];   }   else   {      mTransitions = new Transitions[mRect.h];   }      for (int y = 0; y < mRect.h; y++)   {      mTransitions[y].mLeft = 0;      mTransitions[y].mX.resize(0);   }      mMinX = (mRect.x - 1) << 10;   mMaxX = (mRect.x1()) << 10;   mLeftPos = mRect.x;}

void Ctrl::EventLoop(Ctrl *ctrl){	GuiLock __;	ASSERT_(IsMainThread(), "EventLoop can only run in the main thread");	ASSERT(LoopLevel == 0 || ctrl);	LoopLevel++;	LLOG("Entering event loop at level " << LoopLevel << LOG_BEGIN);	if(!GetMouseRight() && !GetMouseMiddle() && !GetMouseLeft())		ReleaseCtrlCapture();	Ptr<Ctrl> ploop;	if(ctrl) {		ploop = LoopCtrl;		LoopCtrl = ctrl;		ctrl->inloop = true;	}	while(!IsEndSession() &&	      (ctrl ? ctrl->IsOpen() && ctrl->InLoop() : GetTopCtrls().GetCount())) {		FetchEvents(TRUE);		ProcessEvents();	}	if(ctrl)		LoopCtrl = ploop;	LoopLevel--;	LLOG(LOG_END << "Leaving event loop ");}

	bool CWin::RegisterSkin(STRINGorID xml, LPCTSTR type /* = NULL */, IDialogBuilderCallback* pCallback /* = NULL */, CControlUI* pParent /* = NULL */)	{		DuiLogInfo(_T("RegisterSkin xml:%s,type:%s"), (LPCTSTR)xml.m_lpstr, type == NULL ? _T("0") : type);		assert(IsWindow());		assert(IsMainThread());		UnRegisterSkin();		_paintManager = new CPaintManagerUI();		_paintManager->Init(m_hWnd);				CControlUI* pRoot = this->CreateRoot(xml,type,pCallback,pParent);		if (!pRoot)			DuiLogError(_T("RegisterSkin xml:%s,type:%s"), (LPCTSTR)xml.m_lpstr, (type == NULL ? _T("0") : type));		CDuiString sError = CDuiString::FormatString(_T("Failed to parse XML:%s"), (LPCTSTR)xml.m_lpstr);		char serror[MAX_PATH] = { 0 };		sprintf_s(serror, MAX_PATH, "Failed to parse XML:%s", (LPCTSTR)xml.m_lpstr);		ASSERT(pRoot && "Failed to parse XML");		DuiAssertX(pRoot, serror);		if (pRoot)		{			_bValid = TRUE;			return _paintManager->AttachDialog(pRoot);		}		return false;	}

//////////////////////////////////////////////////// CreateDeviceSecondCallCheck//// Check for, and handle subsequent calls to create device// Know to occur with RTSSHooks.dll (EVGA Precision X on screen display)//////////////////////////////////////////////////bool CreateDeviceSecondCallCheck(HRESULT& hOutResult, IDirect3D9* pDirect3D, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags,                                 D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DDevice9** ppReturnedDeviceInterface){    static uint uiCreateCount = 0;    // Also check for invalid size    if (pPresentationParameters->BackBufferWidth == 0)    {        WriteDebugEvent(SString(" Passing through call #%d to CreateDevice because size is invalid", uiCreateCount));        return true;    }    // Also check for calls from other threads    if (!IsMainThread())    {        SString strMessage(" Passing through call #%d to CreateDevice because not main thread", uiCreateCount);        WriteDebugEvent(strMessage);        AddReportLog(8627, strMessage);        return true;    }    if (++uiCreateCount == 1)        return false;    WriteDebugEvent(SString(" Passing through call #%d to CreateDevice", uiCreateCount));    hOutResult = pDirect3D->CreateDevice(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface);    return true;}

  bool SchedulerBase::CreateSignalChannel(int *outSigId, SignalCallback callback, void *userdata)  {    LogAssert(IsMainThread());    if (!LogVerify(outSigId) || !LogVerify(callback))      return false;    *outSigId = -1;    // Create a set of pipes    int fdPipe[2];    int flags;    int ret = pipe(fdPipe);    if (ret != 0)    {      gLog.ErrnoError(errno, "Unable to create pipe for signaling");      return false;    }    FileDescriptor pipeRead(fdPipe[0]);    FileDescriptor pipeWrite(fdPipe[1]);    flags = fcntl(pipeRead, F_GETFL);    flags = flags | O_NONBLOCK;    if (-1 == fcntl(pipeRead, F_SETFL, flags))    {      gLog.LogError("Failed to set read pipe to non-blocking.");      return false;    }    flags = fcntl(pipeWrite, F_GETFL);    flags = flags | O_NONBLOCK;    if (-1 == fcntl(pipeWrite, F_SETFL, flags))    {      gLog.LogError("Failed to set write pipe to non-blocking.");      return false;    }    if (!watchSocket(pipeRead))      return false;    schedulerSignalItem item;    item.callback = callback;    item.userdata = userdata;    item.fdWrite = pipeWrite;    item.fdRead = pipeRead;    m_signals[item.fdRead] = item;    pipeWrite.Detach();    pipeRead.Detach();    *outSigId = item.fdWrite;    gLog.Optional(Log::TimerDetail, "Created signal channel from %d to %d .", item.fdWrite, item.fdRead);    return true;  }

void Ctrl::GuiSleep0(int ms){	GuiLock __;	ASSERT(IsMainThread());	LLOG("GuiSleep");	int level = LeaveGuiMutexAll();	FBSleep(ms);	EnterGuiMutex(level);}

 void DestroyShader(unsigned int inShader) {    if ( !IsMainThread() )    {       mHasZombie = true;       mZombieShaders.push_back(inShader);    }    else       glDeleteShader(inShader); }

 void DestroyProgram(unsigned int inProg) {    if ( !IsMainThread() )    {       mHasZombie = true;       mZombiePrograms.push_back(inProg);    }    else       glDeleteProgram(inProg); }

 void DestroyVbo(unsigned int inVbo) {    if ( !IsMainThread() )    {       mHasZombie = true;       mZombieVbos.push_back(inVbo);    }    else       glDeleteBuffers(1,&inVbo); }

 void DestroyTexture(unsigned int inTex) {    if ( !IsMainThread() )    {       mHasZombie = true;       mZombieTextures.push_back(inTex);    }    else       glDeleteTextures(1,&inTex); }

void Ctrl::GuiSleep(int ms){	GuiLock __;	ASSERT(IsMainThread());//	LLOG("GuiSleep");	int level = LeaveGuiMutexAll();	socket.Timeout(ms).WaitRead();	socket.Timeout(20000);	EnterGuiMutex(level);}

 void DestroyRenderbuffer(unsigned int inBuffer) {    if ( !IsMainThread() )    {       mHasZombie = true;       mZombieRenderbuffers.push_back(inBuffer);    }    else       glDeleteRenderbuffers(1,&inBuffer); }

bool Ctrl::SetWndCapture(){	GuiLock __;	ASSERT(IsMainThread());	HWND hwnd = GetHWND();	if(hwnd) {		::SetCapture(hwnd);		return true;	}	return false;}

   void DestroyNativeTexture(void *inNativeTexture)   {      GLuint tid = (GLuint)(size_t)inNativeTexture;      if ( !IsMainThread() )      {         //printf("Warning - leaking texture %d", tid );		 mZombieTextures.push_back(tid);      }      else         glDeleteTextures(1,&tid);   }

void PseudoThreadResume(){  // Must be run from the main thread.  assert(IsMainThread());  // Pseudothread must have been forked.  assert(forked_pseudo_thread_);  // Can only be run from the main thread.  assert(!in_pseudo_thread_);  if (!setjmp(main_thread_state_)) {    // Go back to the pseudo thread after saving state.    longjmp(pseudo_thread_state_, 1);  }  in_pseudo_thread_ = false;}

bool Ctrl::SetWndCapture(){	GuiLock __;	LLOG("Ctrl::SetWndCapture() in " << UPP::Name(this));	ASSERT(IsMainThread());	HWND hwnd = GetHWND();	if(hwnd) {		::SetCapture(hwnd);		LLOG("SetCapture succeeded");		return true;	}	return false;}

bool Ctrl::ReleaseWndCapture0(){	GuiLock __;	ASSERT(IsMainThread());	LLOG("ReleaseWndCapture");	if(grabwindow) {		gdk_pointer_ungrab(CurrentTime);		grabwindow = NULL;		StartGrabPopup();		return true;	}	return false;}

void PseudoThreadHeadroomFork(	  int bytes_headroom, void *(*func)(void *arg), void *arg){  // Must be run from the main thread.  assert(IsMainThread());  // Only one pseudothread can be forked.  assert(!forked_pseudo_thread_);  // Leave a gap of bytes_headroom on the stack between  alloca(bytes_headroom);  // Goto pseudothread, but remeber how to come back here.  if (!setjmp(main_thread_state_)) {    InnerPseudoThreadFork(func, arg);  }  in_pseudo_thread_ = false;}

void CInfoWindow::ShowInfo(HWND hparent,	POINT pt,	LPCTSTR pszText){	assert(IsMainThread());	this->KillTimer(_nTimerId);	ShowWindow(SW_HIDE);	SetText(pszText);//	SetParent(hparent);	AdjustWindow(hparent,pt);	ShowWindow(SW_SHOWNORMAL);	this->SetTimer(_nTimerId,1500);}

bool Ctrl::ProcessEvent(bool *quit){	LLOG("@ ProcessEvent");	ASSERT(IsMainThread());	if(!GetMouseLeft() && !GetMouseRight() && !GetMouseMiddle())		ReleaseCtrlCapture();	if(FBProcessEvent(quit)) {		LLOG("FBProcesEvent returned true");		SyncTopWindows();		DefferedFocusSync();		SyncCaret();		return true;	}	return false;}