pthread_mutex_unlock(&m_mutex);
}
-CLockObject::CLockObject(CMutex *mutex) :
+CLockObject::CLockObject(CMutex *mutex, bool bTryLock /* = false */) :
m_mutex(mutex)
{
- m_mutex->Lock();
+ if (m_mutex)
+ m_bLocked = bTryLock ? m_mutex->TryLock() : m_mutex->Lock();
}
CLockObject::~CLockObject(void)
void CLockObject::Leave(void)
{
- m_mutex->Unlock();
+ if (m_mutex && m_bLocked)
+ {
+ m_bLocked = false;
+ m_mutex->Unlock();
+ }
}
void CLockObject::Lock(void)
{
- m_mutex->Lock();
+ if (m_mutex)
+ m_bLocked = m_mutex->Lock();
}
CCondition::CCondition(void)
pthread_cond_destroy(&m_cond);
}
-void CCondition::Signal(void)
+void CCondition::Broadcast(void)
{
pthread_cond_broadcast(&m_cond);
}
-bool CCondition::Wait(CMutex *mutex, int64_t iTimeout)
+void CCondition::Signal(void)
+{
+ pthread_cond_signal(&m_cond);
+}
+
+bool CCondition::Wait(CMutex *mutex, uint32_t iTimeout /* = 0 */)
{
bool bReturn(false);
- struct timespec abstime;
- struct timeval now;
- if (gettimeofday(&now, NULL) == 0)
+ sched_yield();
+ if (mutex)
{
- iTimeout += now.tv_usec / 1000;
- abstime.tv_sec = now.tv_sec + (time_t)(iTimeout / 1000);
- abstime.tv_nsec = (long)((iTimeout % (unsigned long)1000) * (unsigned long)1000000);
- bReturn = (pthread_cond_timedwait(&m_cond, &mutex->m_mutex, &abstime) == 0);
+ if (iTimeout > 0)
+ {
+ struct timespec abstime;
+ struct timeval now;
+ gettimeofday(&now, NULL);
+ iTimeout += now.tv_usec / 1000;
+ abstime.tv_sec = now.tv_sec + (time_t)(iTimeout / 1000);
+ abstime.tv_nsec = (int32_t)((iTimeout % (uint32_t)1000) * (uint32_t)1000000);
+ bReturn = (pthread_cond_timedwait(&m_cond, &mutex->m_mutex, &abstime) == 0);
+ }
+ else
+ {
+ bReturn = (pthread_cond_wait(&m_cond, &mutex->m_mutex) == 0);
+ }
}
return bReturn;
}
-void CCondition::Sleep(int iTimeout)
+void CCondition::Sleep(uint32_t iTimeout)
{
- sched_yield();
CCondition w;
CMutex m;
CLockObject lock(&m);
- w.Wait(&m, int64_t(iTimeout));
+ w.Wait(&m, iTimeout);
}
CThread::CThread(void) :
- m_bRunning(false),
- m_bStop(false)
+ m_bStop(false),
+ m_bRunning(false)
{
}
CThread::~CThread(void)
{
- m_bStop = true;
- pthread_join(m_thread, NULL);
+ StopThread();
}
-bool CThread::CreateThread(void)
+bool CThread::CreateThread(bool bWait /* = true */)
{
bool bReturn(false);
+ CLockObject lock(&m_threadMutex);
+ m_bStop = false;
if (!m_bRunning && pthread_create(&m_thread, NULL, (void *(*) (void *))&CThread::ThreadHandler, (void *)this) == 0)
{
- m_bRunning = true;
- pthread_detach(m_thread);
+ if (bWait)
+ m_threadCondition.Wait(&m_threadMutex);
bReturn = true;
}
void *CThread::ThreadHandler(CThread *thread)
{
+ void *retVal = NULL;
+
if (thread)
- return thread->Process();
- return NULL;
+ {
+ CLockObject lock(&thread->m_threadMutex);
+ thread->m_bRunning = true;
+ lock.Leave();
+ thread->m_threadCondition.Broadcast();
+
+ retVal = thread->Process();
+
+ lock.Lock();
+ thread->m_bRunning = false;
+ lock.Leave();
+ thread->m_threadCondition.Broadcast();
+ }
+
+ return retVal;
}
-void CThread::StopThread(bool bWaitForExit /* = true */)
+bool CThread::StopThread(bool bWaitForExit /* = true */)
{
+ bool bReturn(true);
m_bStop = true;
- if (bWaitForExit)
- pthread_join(m_thread, NULL);
+
+ m_threadCondition.Broadcast();
+
+ void *retVal;
+ if (bWaitForExit && m_bRunning)
+ bReturn = (pthread_join(m_thread, &retVal) == 0);
+
+ return bReturn;
+}
+
+bool CThread::Sleep(uint32_t iTimeout)
+{
+ CLockObject lock(&m_threadMutex);
+ return m_bStop ? false : m_threadCondition.Wait(&m_threadMutex, iTimeout);
}