/** * Main function */ int main() { // We create a condition CondId cond = CondCreate("TableCondition"); // We create a thread to fill it and one to read it ThreadId thread_fill = newThread("FillThread", (int)fillThread, (int)cond); ThreadId thread_read = newThread("ReadThread", (int)readThread, (int)cond); // Wait the two threads before returning if (Join(thread_fill) < 0) n_printf("Error joining first thread"); n_printf("Thread fill just finished"); if (Join(thread_read) < 0) n_printf("Error joining second thread"); n_printf("Thread read just finished"); // Delete the condition if (CondDestroy(cond) < 0) n_printf("Error destroy lock"); // Exit the program return 0; }
void BuildQueueDestroy(BuildQueue* queue) { Log(kDebug, "destroying build queue"); const BuildQueueConfig* config = &queue->m_Config; MutexLock(&queue->m_Lock); queue->m_QuitSignalled = true; MutexUnlock(&queue->m_Lock); CondBroadcast(&queue->m_WorkAvailable); for (int i = 0, thread_count = config->m_ThreadCount; i < thread_count; ++i) { if (i > 0) { Log(kDebug, "joining with build thread %d", i); ThreadJoin(queue->m_Threads[i]); } ThreadStateDestroy(&queue->m_ThreadState[i]); } // Deallocate storage. MemAllocHeap* heap = queue->m_Config.m_Heap; HeapFree(heap, queue->m_ExpensiveWaitList); HeapFree(heap, queue->m_Queue); CondDestroy(&queue->m_WorkAvailable); MutexDestroy(&queue->m_Lock); // Unblock all signals on the main thread. SignalHandlerSetCondition(nullptr); SignalBlockThread(false); }
TInt CTestCondwait::TestCond411() { int errsum=0, err = 0; int retval = 0; ThreadData lThreadData; sem_t lSignalSemaphore; sem_t lSuspendSemaphore; sem_t lTestSemaphore; pthread_mutex_t lTestMutex; pthread_cond_t lTestCondVar; pthread_condattr_t lCondAttr; pthread_mutexattr_t lTestMutexAttr; pthread_mutexattr_t defaultattr; pthread_mutexattr_t errorcheckattr; pthread_mutexattr_t recursiveattr; pthread_mutexattr_init(&defaultattr); pthread_mutexattr_init(&errorcheckattr); pthread_mutexattr_init(&recursiveattr); pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK); pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE); pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER; CommonData lCommonData; lCommonData.iStaticMutex = &l_staticmutex; lCommonData.iErrorCheckMutex = &l_errorcheckmutex; lCommonData.iRecursiveMutex = &l_recursivemutex; lCommonData.iStaticCondVar = &l_staticcondvar; retval = sem_init(&lSignalSemaphore,0,0); if(retval != 0) { return retval; } retval = sem_init(&lSuspendSemaphore,0,0); if(retval != 0) { return retval; } lThreadData.iSignalSemaphore = &lSignalSemaphore; lThreadData.iSuspendSemaphore = &lSuspendSemaphore; lThreadData.iTestSemaphore = &lTestSemaphore; lThreadData.iTestMutex = &lTestMutex; lThreadData.iTestMutexAttr = &lTestMutexAttr; lThreadData.iTestCondVar = &lTestCondVar; lThreadData.iDefaultAttr = &defaultattr; lThreadData.iErrorcheckAttr = &errorcheckattr; lThreadData.iRecursiveAttr = &recursiveattr; lThreadData.iCondAttr = &lCondAttr; for (int loop = 0; loop < EThreadMain; loop++) { g_spinFlag[loop] = true; } lThreadData.iSuspending = false; lThreadData.iSpinCounter = 0; lThreadData.iCurrentCommand = -1; lThreadData.iSelf = EThreadMain; lThreadData.iValue = 0; lThreadData.iRetValue = 0; lThreadData.ierrno = 0; lThreadData.iExpectederrno = 0; lThreadData.iTimes = 0; lThreadData.iStopped = false; lThreadData.iCommonData = &lCommonData; retval = CondInit(&lThreadData); retval = MutexInitNULL(&lThreadData); fp=func; retval = ThreadCreate(&lThreadData, (void*) EThread1); WaitTillSuspended(&lThreadData, (void*) EThread1); fp=func1; retval = ThreadCreate(&lThreadData, (void*) EThread2); retval = ThreadDestroy(&lThreadData, (void*) EThread1); retval = ThreadDestroy(&lThreadData, (void*) EThread2); retval = MutexDestroy(&lThreadData); retval = CondDestroy(&lThreadData); StopThread(&lThreadData); err = pthread_cond_destroy(&l_staticcondvar); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_recursivemutex); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_errorcheckmutex); if(err != EINVAL) { errsum += err; } err = pthread_mutex_destroy(&l_staticmutex); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&recursiveattr); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&errorcheckattr); if(err != EINVAL) { errsum += err; } err = pthread_mutexattr_destroy(&defaultattr); if(err != EINVAL) { errsum += err; } err = sem_destroy(&lSignalSemaphore); if(err != EINVAL) { errsum += err; } err = sem_destroy(&lSuspendSemaphore); if(err != EINVAL) { errsum += err; } return retval+errsum; }