/******************************************************************************
|
* FILE: MyThread.h
|
* Description:
|
* Critical Section, AutoLock mutex and thread controler Class.
|
*
|
* Modified Code History
|
* Mark Date By Modification Reason
|
*******************************************************************************
|
* 01 2007-1-29 songxw Initial creation.
|
******************************************************************************/
|
|
#ifndef __MYTHREAD_H__
|
#define __MYTHREAD_H__
|
|
using namespace std;
|
|
#include <pthread.h>
|
|
//Class for critical section
|
class CCritSec
|
{
|
public:
|
CCritSec()
|
{
|
pthread_mutex_init(&m_CritSec, NULL);
|
}
|
|
~CCritSec()
|
{
|
pthread_mutex_destroy(&m_CritSec);
|
}
|
|
void Lock()
|
{
|
pthread_mutex_lock(&m_CritSec);
|
}
|
|
void Unlock()
|
{
|
pthread_mutex_unlock(&m_CritSec);
|
}
|
int TryLock()
|
{
|
return pthread_mutex_trylock(&m_CritSec);
|
}
|
private:
|
//make copy constructor and assignment operator inaccessible
|
CCritSec(const CCritSec &refCritSec);
|
CCritSec &operator =(const CCritSec &refCritSec);
|
|
pthread_mutex_t m_CritSec;
|
};
|
|
// locks a critical section, and unlocks it automatically
|
// when the lock goes out of scope
|
class CAutoLock
|
{
|
public:
|
CAutoLock(CCritSec *pLock)
|
{
|
m_pLock = pLock;
|
m_pLock->Lock();
|
}
|
|
~CAutoLock()
|
{
|
m_pLock->Unlock();
|
}
|
|
private:
|
//make copy constructor and assignment operator inaccessible
|
CAutoLock(const CAutoLock &refAutoLock);
|
CAutoLock &operator =(const CAutoLock &refAutoLock);
|
|
CCritSec *m_pLock;
|
};
|
class CAutoTryLock
|
{
|
public:
|
CAutoTryLock(CCritSec *pLock)
|
{
|
m_pLock = pLock;
|
}
|
bool TryLock(){
|
if(m_pLock->TryLock())
|
{
|
isLock = false;
|
}else
|
isLock = true;
|
return isLock;
|
}
|
~CAutoTryLock()
|
{
|
if(isLock)
|
m_pLock->Unlock();
|
}
|
|
private:
|
bool isLock;
|
//make copy constructor and assignment operator inaccessible
|
CAutoTryLock(const CAutoTryLock &refAutoLock);
|
CAutoTryLock &operator =(const CAutoTryLock &refAutoLock);
|
|
CCritSec *m_pLock;
|
};
|
class CAutoBoolSet
|
{
|
public:
|
CAutoBoolSet(bool* pFlag)
|
{
|
pVal = pFlag;
|
*pVal = true;
|
}
|
|
~CAutoBoolSet(void)
|
{
|
*pVal = false;
|
}
|
|
private:
|
bool* pVal;
|
};
|
|
#define THREAD_PRIORITY_NORMAL 0 //Note: linux priority: -128 ~ +128
|
#define THREAD_STACK_SIZE (32 * 1024)
|
#define THREAD_PRIORITY_TIME_CRITICAL 15
|
|
//Class for control thread
|
class CMyThread
|
{
|
public:
|
CMyThread();
|
virtual ~CMyThread();
|
|
//user callable functions
|
int StartThread(int policy = SCHED_FIFO, int Priority = THREAD_PRIORITY_NORMAL, int StackSize = 327680);
|
int StopThread(unsigned long timeout = 1000);
|
int KillThread(); //kill the thread immediately, not implemented yet
|
bool ThreadStatus(){
|
CAutoLock lock(&m_StatusLock);
|
bool status = m_bThreadStarted;
|
return status;
|
};
|
void SetThreadStatus(bool status){
|
CAutoLock lock(&m_StatusLock);
|
m_bThreadStarted = status;
|
};
|
pthread_t GetThreadID(void) {return m_nThreadID;}
|
|
protected:
|
virtual int ThreadProc() = 0; //Main Worker thread function, override
|
int CheckStopEvent();
|
int SetStopEvent()
|
{
|
CAutoLock l(&m_EventLock);
|
m_hStop = 1;
|
return 0;
|
}
|
bool m_bError;
|
|
private:
|
CCritSec m_EventLock;
|
int m_hStop;
|
int GetStopEvent()
|
{
|
CAutoLock l(&m_EventLock);
|
return m_hStop;
|
}
|
|
int ResetStopEvent() { CAutoLock l(&m_EventLock); m_hStop=0; return 0; }
|
|
private:
|
static void *ThreadEntryPoint(void * pParam); // call this->ThreadProc()
|
|
pthread_t m_nThreadID;
|
bool m_bThreadStarted;
|
CCritSec m_APILock; // lock for the API calls
|
CCritSec m_StatusLock;
|
};
|
|
#endif //#ifndef __MYTHREAD_H__
|
