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
}
TEST(TestMultipleSharedSection, General)
{
CSharedSection sec;
CEvent event;
std::atomic<long> mutex(0L);
locker<CSharedLock> l1(sec,&mutex, &event);
{
CSharedLock lock(sec);
thread waitThread1(l1);
EXPECT_TRUE(waitForThread(mutex,1,10000));
SleepMillis(10);
EXPECT_TRUE(l1.haslock);
event.Set();
EXPECT_TRUE(waitThread1.timed_join(MILLIS(10000)));
}
locker<CSharedLock> l2(sec,&mutex,&event);
locker<CSharedLock> l3(sec,&mutex,&event);
locker<CSharedLock> l4(sec,&mutex,&event);
locker<CSharedLock> l5(sec,&mutex,&event);
{
CExclusiveLock lock(sec);
thread waitThread1(l2);
thread waitThread2(l3);
thread waitThread3(l4);
thread waitThread4(l5);
EXPECT_TRUE(waitForThread(mutex,4,10000));
SleepMillis(10);
EXPECT_TRUE(!l2.haslock);
EXPECT_TRUE(!l3.haslock);
EXPECT_TRUE(!l4.haslock);
EXPECT_TRUE(!l5.haslock);
lock.Leave();
EXPECT_TRUE(waitForWaiters(event,4,10000));
EXPECT_TRUE(l2.haslock);
EXPECT_TRUE(l3.haslock);
EXPECT_TRUE(l4.haslock);
EXPECT_TRUE(l5.haslock);
event.Set();
EXPECT_TRUE(waitThread1.timed_join(MILLIS(10000)));
EXPECT_TRUE(waitThread2.timed_join(MILLIS(10000)));
EXPECT_TRUE(waitThread3.timed_join(MILLIS(10000)));
EXPECT_TRUE(waitThread4.timed_join(MILLIS(10000)));
}
}
//--------------------------
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 tst_QWriteLocker::unlockAndRelockTest()
{
class UnlockAndRelockThread : public tst_QWriteLockerThread
{
public:
void run()
{
QWriteLocker locker(&lock);
waitForTest();
locker.unlock();
waitForTest();
locker.relock();
waitForTest();
}
};
thread = new UnlockAndRelockThread;
thread->start();
waitForThread();
// lock should be locked by the QWriteLocker
QVERIFY(!thread->lock.tryLockForWrite());
releaseThread();
waitForThread();
// lock has been explicitly unlocked via QWriteLocker
QVERIFY(thread->lock.tryLockForWrite());
thread->lock.unlock();
releaseThread();
waitForThread();
// lock has been explicity relocked via QWriteLocker
QVERIFY(!thread->lock.tryLockForWrite());
releaseThread();
QVERIFY(thread->wait());
delete thread;
thread = 0;
}
void tst_QMutexLocker::unlockAndRelockTest()
{
class UnlockAndRelockThread : public tst_QMutexLockerThread
{
public:
void run()
{
QMutexLocker locker(&mutex);
waitForTest();
locker.unlock();
waitForTest();
locker.relock();
waitForTest();
}
};
thread = new UnlockAndRelockThread;
thread->start();
waitForThread();
// mutex should be locked by the QMutexLocker
QVERIFY(!thread->mutex.tryLock());
releaseThread();
waitForThread();
// mutex has been explicitly unlocked via QMutexLocker
QVERIFY(thread->mutex.tryLock());
thread->mutex.unlock();
releaseThread();
waitForThread();
// mutex has been explicitly relocked via QMutexLocker
QVERIFY(!thread->mutex.tryLock());
releaseThread();
QVERIFY(thread->wait());
delete thread;
thread = 0;
}
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() );
}
}
}
TEST(TestSharedSection, GetSharedLockWhileTryingExclusiveLock)
{
std::atomic<long> mutex(0L);
CEvent event;
CSharedSection sec;
CSharedLock l1(sec); // get a shared lock
locker<CExclusiveLock> l2(sec,&mutex);
thread waitThread1(l2); // try to get an exclusive lock
EXPECT_TRUE(waitForThread(mutex,1,10000));
SleepMillis(10); // still need to give it a chance to move ahead
EXPECT_TRUE(!l2.haslock); // this thread is waiting ...
EXPECT_TRUE(!l2.obtainedlock); // this thread is waiting ...
// now try and get a SharedLock
locker<CSharedLock> l3(sec,&mutex,&event);
thread waitThread3(l3); // try to get a shared lock
EXPECT_TRUE(waitForThread(mutex,2,10000));
SleepMillis(10);
EXPECT_TRUE(l3.haslock);
event.Set();
EXPECT_TRUE(waitThread3.timed_join(MILLIS(10000)));
// l3 should have released.
EXPECT_TRUE(!l3.haslock);
// but the exclusive lock should still not have happened
EXPECT_TRUE(!l2.haslock); // this thread is waiting ...
EXPECT_TRUE(!l2.obtainedlock); // this thread is waiting ...
// let it go
l1.Leave(); // the last shared lock leaves.
EXPECT_TRUE(waitThread1.timed_join(MILLIS(10000)));
EXPECT_TRUE(l2.obtainedlock); // the exclusive lock was captured
EXPECT_TRUE(!l2.haslock); // ... but it doesn't have it anymore
}
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 tst_QWriteLocker::scopeTest()
{
class ScopeTestThread : public tst_QWriteLockerThread
{
public:
void run()
{
waitForTest();
{
QWriteLocker locker(&lock);
waitForTest();
}
waitForTest();
}
};
thread = new ScopeTestThread;
thread->start();
waitForThread();
// lock should be unlocked before entering the scope that creates the QWriteLocker
QVERIFY(thread->lock.tryLockForWrite());
thread->lock.unlock();
releaseThread();
waitForThread();
// lock should be locked by the QWriteLocker
QVERIFY(!thread->lock.tryLockForWrite());
releaseThread();
waitForThread();
// lock should be unlocked when the QWriteLocker goes out of scope
QVERIFY(thread->lock.tryLockForWrite());
thread->lock.unlock();
releaseThread();
QVERIFY(thread->wait());
delete thread;
thread = 0;
}
//--------------------------------------------------------------
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;
}
int ThreadedAudioDevice::doStop()
{
if (!stopping()) {
PRINT1("\tThreadedAudioDevice::doStop\n");
stopping(true); // signals play thread
paused(false);
waitForThread();
starting(false);
}
return 0;
}
