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

int Thread::start(int32_t id) {    Thread *thread = getThread(id);    if (thread == NULL || thread->starting || id==main_threadid)        return 1;    if(thread->state == THREAD_RUNNING)        return 2;    if(thread->terminated)        return 4;    thread->exited = false;    thread->state = THREAD_CREATED;    thread->starting = 1;#ifdef WIN32_    thread->thread = CreateThread(            NULL,                   // default security attributes            0,                      // use default stack size            &vm->InterpreterThreadStart,       // thread function caller            thread,                 // thread self when thread is created            0,                      // use default creation flags            NULL);    if(thread->thread == NULL) return 3; // thread was not started    else return waitForThread(thread);#endif#ifdef POSIX_    if(pthread_create( &thread->thread, NULL, vm->InterpreterThreadStart, (void*) thread))        return 3; // thread was not started    else {        return waitForThread(thread);    }#endif}

int Thread::startDaemon(#ifdef WIN32_        DWORD WINAPI#endif#ifdef POSIX_void*#endif(*threadFunc)(void *), Thread *thread) {    if (thread == NULL || !thread->daemon)        return 1;    if(thread->state == THREAD_RUNNING)        return 2;    thread->exited = false;#ifdef WIN32_    thread->thread = CreateThread(            NULL,                   // default security attributes            0,                      // use default stack size            (LPTHREAD_START_ROUTINE)threadFunc,       // thread function caller            thread,                 // thread self when thread is created            0,                      // use default creation flags            NULL);    if(thread->thread == NULL) return 3; // thread was not started    else        return waitForThread(thread);#endif#ifdef POSIX_    if(pthread_create( &thread->thread, NULL, threadFunc, (void*) thread)!=0)        return 3; // thread was not started    else        return waitForThread(thread);#endif}

//--------------------------bool ofxTCPServer::close(){    stopThread();	if( !TCPServer.Close() ){		ofLogWarning("ofxTCPServer") << "close(): couldn't close connections";		waitForThread(false); // wait for the thread to finish		return false;    }else{        ofLogVerbose("ofxTCPServer") << "Closing server";		waitForThread(false); // wait for the thread to finish		return true;	}}

//--------------------------------------------------------------------------------void ofxKinectV2::close(){    if( bOpened ){        waitForThread(true);        protonect.closeKinect();        bOpened = false;    }}

DetachThreadQueue::~DetachThreadQueue(){		timeToStop = true;	//lets flag the thread so that it doesnt try access stuff while we delete things around		if(verbose) printf("DetachThreadQueue::~DetachThreadQueue() waiting for queue thread.../n");	if (isThreadRunning())		waitForThread();		if(verbose) printf("DetachThreadQueue::~DetachThreadQueuedeleting deleting pending, processing and processed work units.../n");	while ( processing.size() > 0 ){		GenericWorkUnit * w = processing[0];		if ( w->isThreadRunning() ){			w->weAreBeingDeleted = true;			w->cancel();			if(verbose) printf("WorkUnit(%d) waitForThread at destructor /n", w->getID());			w->waitForThread();		}		processing.erase( processing.begin() );		delete w;	}		while ( pending.size() > 0 ){				GenericWorkUnit * w = pending[0];		pending.erase( pending.begin() );		delete w;			}	while ( processed.size() > 0 ){				GenericWorkUnit * w = processed[0];		processed.erase( processed.begin() );		delete w;	}	if(verbose) printf("~DetachThreadQueue() done!/n");}

void ofxThreadedMidiPlayer::stop(){    cout << __PRETTY_FUNCTION__ << endl;    stopThread();    waitForThread();    // clean();    }

//--------------------------------------------------------------void ofxVideoRecorder::threadedFunction(){    if(bRecordVideo && bRecordAudio) {        while(frames.size() > 0 && audioFrames.size() > 0) {            // if there are frames in the queue or the thread is writing, signal them until the work is done.            videoThread.signal();            audioThread.signal();        }    }    else if(bRecordVideo) {        while(frames.size() > 0) {            // if there are frames in the queue or the thread is writing, signal them until the work is done.            videoThread.signal();        }    }    else if(bRecordAudio) {        while(audioFrames.size() > 0) {            // if there are frames in the queue or the thread is writing, signal them until the work is done.            audioThread.signal();        }    }        waitForThread();        outputFileComplete();}

//---------------------------------------------------------------------------void ofxKinect::close(){	if(isThreadRunning()){		waitForThread(true);	}		bNeedsUpdate	= false;	bUpdateTex		= false;}

KinectGrabber::~KinectGrabber(){	// when the class is destroyed	// close both channels and wait for	// the thread to finish    //	toAnalyze.close();    //	analyzed.close();	waitForThread(true);}

void ofxColorStream::exit(){	stopThread();	waitForThread();	stream->stop();	stream->destroy();}

//--------------------------------------------------------------IntelFaceScanner::~IntelFaceScanner(){	scanningData.close();		waitForThread(true);	close();}

 //-------------------------------------------------------------- void Reactor::exit(){     if (context != NULL)     {         waitForThread(true);         libwebsocket_context_destroy(context);         context = NULL;     } }

ImgAnalysisThread::~ImgAnalysisThread(){	// when the class is destroyed	// close both channels and wait for	// the thread to finish	toAnalyze.close();	analyzed.close();	waitForThread(true);}

//--------------------------------------------------------------------------------void ofxKinectV2::close() {	if (!bOpened)		return;	waitForThread(true);	closeKinect();	bOpened = false;}

//--------------------------------------------------------------void CloudsVHXAuth::update(ofEventArgs& args){    if (bNotifyComplete) {                //Wait to ensure the thread has stopped        //JG Added this... Elie please advise        waitForThread(true);                Mode completedMode = mode;        mode = WAITING;        if (completedMode == REQUEST_TOKEN) {            ofNotifyEvent(requestTokenComplete, completeArgs);        }        else if (completedMode == REFRESH_TOKEN) {            ofNotifyEvent(refreshTokenComplete, completeArgs);        }        else if (completedMode == REQUEST_CODE) {            ofNotifyEvent(requestCodeComplete, completeArgs);        }        else if (completedMode == LINK_CODE) {            ofNotifyEvent(linkCodeComplete, completeArgs);        }        else if (completedMode == VERIFY_PACKAGE) {            ofNotifyEvent(verifyPackageComplete, completeArgs);        }        bNotifyComplete = false;    }        time_t nowTime = (ofGetSystemTime() / 1000.f);        // Refresh token if it's expired.    if (mode == WAITING && _tokenExpiry && nowTime > _tokenExpiry) {        if (_refreshToken.empty()) {            requestToken();        }        else {            refreshToken();        }    }        // Reset code if it's expired.    if (_codeExpiry && nowTime > _codeExpiry) {        _code = "";        _codeExpiry = 0;                CloudsVHXEventArgs args;        ofNotifyEvent(codeExpired, args);    }        // Update state if package expired.    if (state == RENTAL && _packageExpiry && nowTime > _packageExpiry) {        state = EXPIRED;        CloudsVHXEventArgs args;        ofNotifyEvent(packageExpired, args);    }}

void ofxOMXPlayer::close(ofEventArgs & a){		ofLogVerbose() << "start ofxOMXPlayer::close";	waitForThread(true);		ofRemoveListener(ofEvents().exit, this, &ofxOMXPlayer::close);	ofLogVerbose() << "reached end of ofxOMXPlayer::close";}

//---------------------------------------------------------------------------void ofxKinect::close() {    if(isThreadRunning()) {        waitForThread(true);    }    //usleep(500000); // some time while thread is stopping ...    //libusb_exit(NULL);}

bool ofxNetworkSyncClientState::close(){	if(isThreadRunning()){		stopThread();		waitForThread();	}	calibrator.close();	server = NULL;	tcpServer = NULL;}

ofxThreadedImage::~ofxThreadedImage(){	if (isThreadRunning()){		try {			waitForThread(true);		}catch(Exception &ex) {			ofLogError("ofxThreadedImage", "Exception at waitForThread %s/n", ex.displayText().c_str() );		}	}}

    void cancel(){		if(loading){			ofRemoveListener(ofEvents().update, this, &ofxImageSequenceLoader::updateThreadedLoad);            lock();			cancelLoading = true;            unlock();            loading = false;			waitForThread(true);		}    }

ThreadedAudioDevice::~ThreadedAudioDevice(){	// This code handles the rare case where the child thread is starting	// at the same instant that the device is being destroyed.	PRINT1("~ThreadedAudioDevice/n");	if (starting() && _thread != 0) {		waitForThread();		starting(false);	}}

//--------------------------------------------------------------ofxThreadedVideo::~ofxThreadedVideo(){    // stop threading    waitForThread(true);    // close anything left open    videos[0].close();    videos[1].close();}

//--------------------------------------------------------------void Reactor::exit() {    if (context != NULL)    {        waitForThread(true);        // on windows the app does crash if the context is destroyed        // while the thread or the library still might hold pointers        // better to live with non deleted memory, or?        //libwebsocket_context_destroy(context);        context = NULL;    }}

//---------------------------------------------------------------------------void ofxKinect::close() {	if(isThreadRunning()) {		waitForThread(true);	}	deviceId = -1;	serial = "";	bIsFrameNew = false;	bNeedsUpdate = false;	bUpdateTex = false;}