游戏服务器之跨平台线程的实现

一个跨windows和linux平台的线程基类的实现。

需要实现的在头文件的接口如下

实现的功能就是一些线程的基本功能（部分功能需要的话还需要拓展，在子类实现）：

例程、挂起、恢复、终止、线程句柄、线程id.

不同平台也会有些差异，主要是使用上，对于线程id、互斥量、条件变量的使用。只有windows有线程句柄，windows的线程事件通知和等待是通过线程句柄，linux使用条件变量。线程间同步都可以使用互斥量。

现在已经有人做了类似的功能使windows和linux下使用相同的方法和类来实现线程的跨平台，连名字都是相同的，以后会分析下那个第三方库。

               

#ifdef WINDOWS
/* 线程基础类
*/
class CBaseThread
{
private:
HANDLE
m_hThread; //线程句柄
DWORD m_dwThreadId;//线程ID
bool m_boTerminated;//线程终止标记，子类在线程例程循环中应当通过调用terminated函数判断线程是否被设置了终止标记
private:
HANDLE CreateThreadHandle(const DWORD dwFlags);
static void CALLBACK ThreadRoutine(CBaseThread *lpThread);
protected:
inline bool blocking(){return true;}
//terminated函数用于判断现成是否被设置了终止标记
inline bool terminated(){ return m_boTerminated; }
//线程事物处理例程函数，子类应当继承此函数
virtual void OnRountine();
//线程被终止后的通知函数，nSuspendCount参数表示线程被终止的次数
virtual void OnSuspend(int nSuspendCount);
//线程被恢复后的通知函数，nSuspendCount参数表示线程还需恢复多少次后才能恢复执行,为0表示线程已恢复执行
virtual void OnResume(int nSuspendCount);
//线程例程终止后的通知函数
virtual void OnTerminated();
public:
CBaseThread();
CBaseThread(bool boCreateSuspended);
~CBaseThread();

//获取线程句柄
inline HANDLE getHandle(){ return m_hThread; }
//获取线程ID
inline DWORD getThreadId(){ return m_dwThreadId; }
//暂停线程的执行，返回值表示线程到本次暂停操作后为止总计被暂停的次数。若返回-1则表示暂停线程失败。
int suspend();
//恢复线程的执行，返回值表示线程到本次恢复操作后，线程仍需恢复多少次才能恢复执行。
//若返回-1则表示恢复线程失败，返回0表示线程已经完全恢复执行。
int resume();
//获取线程优先级,失败会返回THREAD_PRIORITY_ERROR_RETURN，否则返回值表示线程优先级
int getPriority();
//设置线程优先级，成功则返回true
bool setPriority(int nPriority);
//等待线程执行完毕，dwWaitLong参数表示等待的最大毫秒数，INFINITE表示无限等待。
//注意，调用此函数的线程在此线程执行完毕后会一直处于阻塞状态
//参数boWaitAlertAble表示调用线程在阻塞期间是否允许进入警告状态（仅对于windows有效)
int waitFor(DWORD dwWaitLong = INFINITE, bool boWaitAlertAble = true);
//标记线程的终止标记
void terminate();
};
#else//linux
class CBaseThread
{
public:
friend void *threadRoutine(CBaseThread *lpThread);
CBaseThread();
CBaseThread(bool boCreateSuspended);
virtual ~CBaseThread();
int suspend();
int resume();
int getPriority();
bool setPriority(int nPriority);
void terminate();
///暂时无限等待
int waitFor();
protected:
inline bool blocking()
{
if(m_isBlock)
{
pthread_mutex_lock(&m_blockMutex);
pthread_cond_wait(&m_blockCond, &m_blockMutex);
}
return true;
}
inline bool terminated(){ return m_isBlock; }
virtual void OnRountine(){};
virtual void OnSuspend(int nSuspendCount){};
virtual void OnResume(int nSuspendCount){};
virtual void OnTerminated(){};
private:
void createThread();
static void *threadRoutine(CBaseThread *lpThread);
private:
pthread_t m_pid;
pthread_mutex_t m_blockMutex;
pthread_cond_t m_blockCond;
bool m_isBlock;
};

#endif

源文件中的代码实现：

WINDOWS是自定义的windows下的宏

#ifdef WINDOWS

CBaseThread::CBaseThread()

{
m_hThread = NULL;
m_dwThreadId = 0;
m_boTerminated = false;
CreateThreadHandle( 0 );

}

CBaseThread::CBaseThread(bool boCreateSuspended)

{
m_hThread = NULL;
m_dwThreadId = 0;
m_boTerminated = false;
CreateThreadHandle( boCreateSuspended ? CREATE_SUSPENDED : 0 );

}

CBaseThread::~CBaseThread()

{
terminate();
waitFor();
if ( m_hThread )
{
CloseHandle( m_hThread );
m_hThread = NULL;
}

}

HANDLE CBaseThread::CreateThreadHandle(const DWORD dwFlags)

{
m_hThread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)ThreadRoutine, this, dwFlags, &m_dwThreadId);
return m_hThread;

}

void CALLBACK CBaseThread::ThreadRoutine(CBaseThread *lpThread)

{
lpThread->OnRountine();
lpThread->OnTerminated();
ExitThread(0);

}

void CBaseThread::OnRountine()

{

}

void CBaseThread::OnSuspend(int nSuspendCount)

{

}

void CBaseThread::OnResume(int nSuspendCount)

{

}

void CBaseThread::OnTerminated()

{

}

int CBaseThread::suspend()

{
DWORD dwSuspended;
dwSuspended = SuspendThread( m_hThread );
if ( dwSuspended != -1 )
{
OnSuspend(dwSuspended + 1);
return dwSuspended + 1;
}
return dwSuspended;

}

int CBaseThread::resume()

{
DWORD dwSuspended;
dwSuspended = ResumeThread( m_hThread );
if ( dwSuspended != -1 )
{
OnResume(dwSuspended - 1);
return dwSuspended - 1;
}
return dwSuspended;

}

int CBaseThread::getPriority()

{
return GetThreadPriority( m_hThread );

}

bool CBaseThread::setPriority(int nPriority)

{
return SetThreadPriority( m_hThread, nPriority ) != 0;

}

int CBaseThread::waitFor(DWORD dwWaitLong, bool boWaitAlertAble)

{
return WaitForSingleObjectEx( m_hThread, dwWaitLong, boWaitAlertAble );

}

void CBaseThread::terminate()

{
m_boTerminated = true;

}

#else

namespace lib

{
namespace thread
{

CBaseThread::CBaseThread()
{
m_pid = 0;
m_isBlock = false;
pthread_mutex_init(&m_blockMutex, 0);
pthread_cond_init(&m_blockCond, 0);
createThread();
}
CBaseThread::CBaseThread(bool boCreateSuspended)
{
m_pid = 0;
m_isBlock = true;
pthread_mutex_init(&m_blockMutex, 0);
pthread_cond_init(&m_blockCond, 0);
createThread();
}
CBaseThread::~CBaseThread()
{
pthread_mutex_destroy(&m_blockMutex);
pthread_cond_destroy(&m_blockCond);
}

int CBaseThread::suspend()
{
m_isBlock = true;
///暂时返回
return 0;
}

int CBaseThread::resume()
{
m_isBlock = false;
pthread_cond_signal(&m_blockCond);
///暂时返回
return 0;
}

int CBaseThread::getPriority()
{
int policy;
sched_param sp;
if(0 != pthread_getschedparam(m_pid, &policy, &sp))
{
return 0;
}
return sp.sched_priority;
}

bool CBaseThread::setPriority(int nPriority)
{
sched_param sp = {nPriority};
if(0 == pthread_setschedparam(m_pid, SCHED_RR, &sp))
{
return true;
}
return false;
}

void CBaseThread::terminate()
{
pthread_cancel(m_pid);
}

int CBaseThread::waitFor()
{
pthread_join(m_pid, 0);
return 0;
}

void CBaseThread::createThread()
{
pthread_create(&m_pid, 0, (LPTHREAD_START_ROUTINE)(&CBaseThread::threadRoutine), this);
}

void *CBaseThread::threadRoutine(CBaseThread *lpThread)
{
lpThread->OnRountine();
lpThread->OnTerminated();
pthread_exit(0);
}
}

}

#endif