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

//---------------------------------------------------------------void threadedEncoding::threadedFunction(){    if(lock()){        encode(fileName, audioFileName, frameRate,compression,exportAudio);        unlock();    }    stopThread();}

 bool Camera::close() {     stopThread();     // for some reason waiting for the thread keeps it from     // completing, but sleeping then stopping capture is ok.     ofSleepMillis(100);     stopCapture(); }

// ----------------------------------------------------------------------------void ofOpenALSoundPlayer::stop(){	alSourceStopv(channels,&sources[sources.size()-channels]);	if(isStreaming){		setPosition(0);		stopThread();	}}

// the principal program sequencevoid VisionEngine::start() {    	if (!interface_) interface_ = new ConsoleInterface(app_name_.c_str());		if (!interface_->openDisplay(this)) {		delete interface_;		interface_ = new ConsoleInterface(app_name_.c_str());		interface_->openDisplay(this);	}	    if(camera_==NULL ) {        interface_->displayError("No camera found!");        return;    }        if( camera_->startCamera() ) {                initFrameProcessors();        startThread();        mainLoop();        stopThread();            } else interface_->displayError("Could not start camera!");        teardownCamera();    freeBuffers();}

//--------------------------------------------------------------// Stops the client thread.  You don't really need to do this ever.//--------------------------------------------------------------void mpeClientTCP::stop() {    out("Quitting.");    stopThread();	if(useMainThread){		ofRemoveListener(ofEvents.draw, this, &mpeClientTCP::draw);	}}

//--------------------------------------------------------------// Stops the client thread.  You don't really need to do this ever.//--------------------------------------------------------------void ofxMPEClient::stop() {    log("Quitting.");    stopThread();    if(useMainThread){        ofRemoveListener(ofEvents().draw, this, &ofxMPEClient::draw);    }}

//-------------------------------------------------void ofThread::waitForThread(bool callStopThread, long milliseconds){	if(!threadDone){		// tell thread to stop        if(callStopThread){            stopThread();		}		// wait for the thread to finish        if(isCurrentThread()){			return; // waitForThread should only be called outside thread		}        if (INFINITE_JOIN_TIMEOUT == milliseconds){			if(thread.joinable()){				try{					thread.join();				}catch(...){}			}        }else{            // Wait for "joinWaitMillis" milliseconds for thread to finish            std::unique_lock<std::mutex> lck(mutex);            if(!threadDone && condition.wait_for(lck,std::chrono::milliseconds(milliseconds))==std::cv_status::timeout){				// unable to completely wait for thread            }        }    }}

	void Renderinstance::shutdownRenderer()	{		stopThread();		if (m_pRenderer!=0) delete m_pRenderer; m_pRenderer=0;		if ((m_pScene!=0) && (m_pScene!=m_pTestscene)) delete m_pScene; m_pScene=0;		if (m_pTestscene!=0) delete m_pTestscene; m_pTestscene=0;	}

// ----------------------------------------------------------------------------// Stop the thread and DMX interface//DMX_STATUS AbstractDMXDriver::stop() {    if ( !stopThread() )        return DMX_ERROR;    // Disconnect interface    return dmx_close();}

    //--------------------------------------------------------------    void threadedClock::stop()    {        // Stop thread        stopThread();    }

//-------------------------------------------------void ofThread::waitForThread(bool callStopThread, long milliseconds){	if(thread.isRunning()){		threadBeingWaitedFor = true;		// tell thread to stop		if(callStopThread){            stopThread();			ofLogVerbose("ofThread") << "- name: " << getThreadName() << " - Signaled to stop.";		}		// wait for the thread to finish		ofLogVerbose("ofThread") << "- name: " << getThreadName() << " - waiting to stop";        if(isCurrentThread()){			ofLogWarning("ofThread") << "- name: " << getThreadName() << " - waitForThread should only be called from outside the this ofThread.";			return;		}        if (INFINITE_JOIN_TIMEOUT == milliseconds){            thread.join();        }else{            // Wait for "joinWaitMillis" milliseconds for thread to finish            if(!thread.tryJoin(milliseconds)){                ofLogError("ofThread") << "- name: " << getThreadName() << " - Unable to completely waitForThread.";            }        }    }}

ofxPixelPusherUnit::~ofxPixelPusherUnit() {    stopThread();    while (isThreadRunning())        ;    udp.Close();}

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

 void close() {     stop();     stopThread (6000);     deviceOpen = false;     recorder = nullptr;     player = nullptr; }

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

//-------------------------------------------------------------------void pbOscReceiver::close(){	_cb = 0;	if ( _threaded ) {		stopThread();		//TODO - it crashes application!	}	//oscReceiver.close();}

NMListener::~NMListener() {  DBG(__func__ << ": cleanup thread");  if (isThreadRunning()) {    signalThreadShouldExit();    notify();    stopThread(2000);  }}

// ----------------------------------------------------------------------------//bool AnimationTask::stop(){    clearAnimations();    if ( !stopThread() )        return false;    return true;}

void CryptobullionApplication::startThread(){    coreThread = new QThread(this);    CryptobullionCore *executor = new CryptobullionCore();    executor->moveToThread(coreThread);    /*  communication to and from thread */    connect(executor, SIGNAL(initializeResult(int)), this, SLOT(initializeResult(int)));    connect(executor, SIGNAL(shutdownResult(int)), this, SLOT(shutdownResult(int)));    connect(executor, SIGNAL(runawayException(QString)), this, SLOT(handleRunawayException(QString)));    connect(this, SIGNAL(requestedInitialize()), executor, SLOT(initialize()));    connect(this, SIGNAL(requestedShutdown()), executor, SLOT(shutdown()));    /*  make sure executor object is deleted in its own thread */    connect(this, SIGNAL(stopThread()), executor, SLOT(deleteLater()));    connect(this, SIGNAL(stopThread()), coreThread, SLOT(quit()));    coreThread->start();}

void SpeechSystem::destroy(){	if (verbose) printf("SpeechSystem::destroy()/n");	/* calling j_close_stream(recog) at any time will terminate     recognition and exit j_recognize_stream() */	j_close_stream(recog);	stopThread();}

SoundBuffer::~SoundBuffer(){	stopThread();	delete m_nextBufferSegmentFillRequest;	delete m_nextBufferSegmentFillCompleted;	delete m_updatingStream;}

// ----------------------------------------------------------------------------void ofOpenALSoundPlayer::stop(){	if(sources.empty()) return;	std::unique_lock<std::mutex> lock(mutex);	alSourceStopv(channels,&sources[sources.size()-channels]);	if(isStreaming){		setPosition(0);		stopThread();	}}

void ListFileProvider::refresh(){	stopThread();	clearItems();	if ( !paths_.empty() ) 		startThread();}

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

void ofxPS3EyeGrabber::stop(){    stopThread();    if (_cam)    {        _cam->stop();    }}

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

ofxTCPSyncClient::~ofxTCPSyncClient() {	stopThread();	if(bTCP)		tcpClient.close();	else{		udpSender.Close();		udpReceiver.Close();	}}

 void close() {     if (isRunning)     {         stopThread (2000);         isRunning = false;         closeDevices();     } }

void ofxMSAThreadedImageSaver::threadedFunction() {	if(lock()) {		saveImage(fileName);		unlock();	} else {		printf("ofxMSAThreadedImageSaver - cannot save %s cos I'm locked", fileName.c_str());	}	stopThread();}

threadedSerial::~threadedSerial(){	if( isThreadRunning() ) { 		stopThread();	}    //    oscSender.clear();}