版权声明: https://blog.csdn.net/dashoumeixi/article/details/83928468
/*
线程函数如果声明在类中, 则需要静态函数.
否则普通函数中将压入this参数 .
所以在类中先声明一个静态函数,用于线程的启动.
再写一个虚函数 run , 在线程中调用, 也可以用于子类的重写
*/
class ThreadObject{
public:
ThreadObject() : m_thread(NULL), m_threadId(0){
}
void startThread(){
m_thread = (HANDLE)_beginthreadex(NULL,
0,
ThreadObject::thread_func, //静态函数
(void*)this, //把this指针传入线程
0,
&m_threadId);
if(m_thread)
cout << "lauched , tid:" << m_threadId << endl;
else
cout << "error : " << GetLastError() << endl;
}
static unsigned __stdcall thread_func(void *param){
ThreadObject *pthis = (ThreadObject *)param; // this
return pthis->run();
}
void waitThread(){
if(m_thread){
WaitForSingleObject(m_thread,-1);
CloseHandle(m_thread);
}
}
virtual DWORD run() = 0; //线程中真正执行的代码
HANDLE m_thread;
unsigned m_threadId;
};
CRITICAL_SECTION 的在c++中的使用:
//封装一个关键段 , enter 与 leave 在下面的例子中将被替换
class CS{
CRITICAL_SECTION m_cs;
public:
CS(){
InitializeCriticalSectionAndSpinCount(&m_cs,4000);
}
~CS(){
DeleteCriticalSection(&m_cs);
}
void enter(){
EnterCriticalSection(&m_cs);
}
void leave(){
LeaveCriticalSection(&m_cs);
}
};
//简化CS的使用 , 省的一直调用 enter , leave
class CSLock{
CS * cs;
public:
CSLock(CS * p) : cs(p){
cs->enter();
}
~CSLock(){
cs->leave();
}
};
//一个测试类
class Str{
public:
Str():pData(0){}
virtual ~Str(){
CSLock s(&mcs); //~CSLock将自动被调用
if(pData)
delete[] pData;
}
virtual void set(char * str){
CSLock s(&mcs);
if(pData)
delete[] pData;
pData = new char[strlen(str) + 1];
strcpy(pData,str);
}
int len(){
if(!pData)
return 0;
CSLock s(&mcs);
int len = strlen(pData);
return len;
}
private:
CS mcs;
char *pData;
};
抽象上面的锁 , 用关键段作为例子:
// 一个锁的基类 , 具体是CS, mutex, semphore , rwlock 无所谓
class LockableObject {
public:
LockableObject(){}
virtual ~LockableObject(){}
virtual void lock() = 0;
virtual void unlock() = 0;
};
// 用CS实现
class SubClassCS : public LockableObject
{
public:
SubClassCS() {
InitializeCriticalSectionAndSpinCount(&cs,4000);
}
virtual ~SubClassCS() {
DeleteCriticalSection(&cs);
}
virtual void lock() {
EnterCriticalSection(&cs);
}
virtual void unlock(){
LeaveCriticalSection(&cs);
}
private:
CRITICAL_SECTION cs;
};
//以后使用这个锁对象即可.
class UseLock {
public:
UseLock(LockableObject * lock) : m_lock(lock){
m_lock->lock();
}
~UseLock(){
m_lock->unlock();
}
private:
LockableObject * m_lock;
};