一个高效率的线程池类
MMORPG游戏服务端线程池类
线程池:
线程是一种比较昂贵的资源.有些系统为了重用线程.引入了线程池的机制.
线程池的工作原理如下：
首先.系统会启动一定数量的线程.这些线程就构成了一个线程池.当有任务要做的时候.系统就从线程池里面选一个空闲的线程.然后把这个线程标记为“正在运行”.然后把任务传给这个线程执行.线程执行任务完成之后.就把自己标记为"空闲".这个过程并不难以理解.难以理解的是.一般来说.线程执行完成之后.运行栈等系统资源就会释放.线程对象就被回收了.一个已经完成的线程.又如何能回到线程池的空闲线程队列中呢? 秘诀就在于.线程池里面的线程永远不会执行完成.线程池里面的线程都是一个无穷循环
ThreadStarter.h
#ifndef __THREADSTARTER_H__
#define __THREADSTARTER_H__
#include < windows.h >
// 线程接口
class ThreadBase
{
public :
ThreadBase() {}
virtual ~ ThreadBase() {}
virtual bool run() = 0 ; // 线程函数
virtual void OnShutdown() {}
HANDLE THREAD_HANDLE;
};
#endif
Threads.h
#ifndef __CTHREADS_H__
#define __CTHREADS_H__
#include " ThreadStarter.h "
// 线程的状态
enum CThreadState
{
THREADSTATE_TERMINATE = 0 , // 终止
THREADSTATE_PAUSED = 1 , // 暂停
THREADSTATE_SLEEPING = 2 , // 睡眠
THREADSTATE_BUSY = 3 , // 忙碌
THREADSTATE_AWAITING = 4 , // 等候
};
// 线程基类
class CThread : public ThreadBase
{
public :
CThread();
~ CThread();
virtual bool run();
virtual void OnShutdown();
// 设置线程的状态
__forceinline void SetThreadState(CThreadState thread_state)
{
ThreadState = thread_state;
}
// 返回线程的状态
__forceinline CThreadState GetThreadState()
{
return ThreadState;
}
// 返回线程ID
int GetThreadId()
{
return ThreadId;
}
time_t GetStartTime()
{
return start_time;
}
protected :
CThreadState ThreadState; // 线程的状态
time_t start_time;
int ThreadId; // 线程ID
};
#endif
Threads.cpp
#include " stdafx.h "
#include " CThreads.h "
CThread::CThread() : ThreadBase()
{
// 初试化线程的状态为等候
ThreadState = THREADSTATE_AWAITING;
start_time = 0 ;
}
CThread:: ~ CThread()
{
}
bool CThread::run()
{
return false ;
}
void CThread::OnShutdown()
{
SetThreadState(THREADSTATE_TERMINATE);
}
Mutex.h
#ifndef __MUTEX_H__
#define __MUTEX_H__
#include < windows.h >
// 多个线程操作相同的数据时，一般是需要按顺序访问的，否则会引导数据错乱
// 为解决这个问题，就需要引入互斥变量，让每个线程都按顺序地访问变量。
class Mutex
{
public :
Mutex();
~ Mutex();
__forceinline void Acquire()
{
EnterCriticalSection( & cs);
}
__forceinline void Release()
{
LeaveCriticalSection( & cs);
}
/*
例如：
线程操作函数。
int AddCount(void)
{
EnterCriticalSection(&cs);
int nRet = m_nCount++;
LeaveCriticalSection(&cs);
return nRet;
}
在函数AddCount里调用EnterCriticalSection和LeaveCriticalSection来互斥访问变量m_nCount。
通过上面这种方法，就可以实现多线程按顺序地访问相同的变量
*/
__forceinline bool AttemptAcquire()
{
// 一个线程也可以调用TryEnterCriticalSection函数来请求某个临界区的所有权,此时即
// 使请求失败也不会被阻塞
return 0 ; // (TryEnterCriticalSection(&cs) == TRUE ? true : false);
}
protected :
CRITICAL_SECTION cs; // 临界区是一种防止多个线程同时执行一个特定代码节的机制
};
#endif
Mutex.cpp
#include " stdafx.h "
#include " Mutex.h "
Mutex::Mutex()
{
// 创建临界区对象
InitializeCriticalSection( & cs);
}
Mutex:: ~ Mutex()
{
// 删除临界区对象
DeleteCriticalSection( & cs);
}
#ifndef __THREADPOOL_H__
#define __THREADPOOL_H__
#include " ThreadStarter.h "
#include " Mutex.h "
#include < windows.h >
#include < assert.h >
#include < set >
typedef unsigned int uint32;
typedef signed __int32 int32;
// 线程管理
class ThreadController
{
public :
HANDLE hThread;
uint32 thread_id;
void Setup(HANDLE h)
{
hThread = h;
}
void Suspend()
{
assert(GetCurrentThreadId() == thread_id);
// 当线程做完任务或者现在想暂停线程运行，就需要使用SuspendThread来暂停线程的执行
SuspendThread(hThread);
}
// 恢复线程的执行就是使用ResumeThread函数了
void Resume()
{
assert(GetCurrentThreadId() != thread_id);
if ( ! ResumeThread(hThread))
{
DWORD le = GetLastError();
printf( " error: %u/n " , le);
}
}
void Join()
{
// WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds就返回
WaitForSingleObject(hThread, INFINITE);
}
uint32 GetId()
{
return thread_id;
}
};
struct Thread
{
ThreadBase * ExecutionTarget;
ThreadController ControlInterface;
Mutex SetupMutex; // 线程的互斥
bool DeleteAfterExit;
};
typedef std:: set < Thread *> ThreadSet;
// 线程池类
class CThreadPool
{
// uint32 _threadsRequestedSinceLastCheck;
// uint32 _threadsFreedSinceLastCheck;
// uint32 _threadsExitedSinceLastCheck;
uint32 _threadsToExit;
int32 _threadsEaten; // 可用线程数量
Mutex _mutex;
ThreadSet m_activeThreads; // 正在执行任务线程对列
ThreadSet m_freeThreads; // 可用线程对列
public :
CThreadPool();
void IntegrityCheck();
// 创建指定数量的线程并加到线程池
void Startup();
// 销毁线程
void Shutdown();
bool ThreadExit(Thread * t);
Thread * StartThread(ThreadBase * ExecutionTarget);
// 从线程池取得可用线程并执行任务
void ExecuteTask(ThreadBase * ExecutionTarget);
void ShowStats();
void KillFreeThreads(uint32 count);
// __forceinline void Gobble(){
// _threadsEaten=(int32)m_freeThreads.size();
// }
__forceinline uint32 GetActiveThreadCount(){
return (uint32)m_activeThreads.size();
}
__forceinline uint32 GetFreeThreadCount(){
return (uint32)m_freeThreads.size();
}
};
extern CThreadPool ThreadPool; // 线程池
#endif
#include " stdafx.h "
#include " ThreadPool.h "
#include < process.h >
CThreadPool ThreadPool;
CThreadPool::CThreadPool()
{
// _threadsExitedSinceLastCheck = 0;
// _threadsRequestedSinceLastCheck = 0;
_threadsEaten = 0 ;
// _threadsFreedSinceLastCheck = 0;
}
bool CThreadPool::ThreadExit(Thread * t)
{
_mutex.Acquire();
m_activeThreads.erase(t);
if (_threadsToExit > 0 )
{
-- _threadsToExit;
// ++_threadsExitedSinceLastCheck;
if (t -> DeleteAfterExit)
m_freeThreads.erase(t);
_mutex.Release();
delete t;
return false ;
}
// enter the "suspended" pool
// ++_threadsExitedSinceLastCheck;
++ _threadsEaten;
std:: set < Thread *> ::iterator itr = m_freeThreads.find(t);
if (itr != m_freeThreads.end())
{
}
m_freeThreads.insert(t);
_mutex.Release();
return true ;
}
void CThreadPool::ExecuteTask(ThreadBase * ExecutionTarget)
{
Thread * t;
_mutex.Acquire();
// ++_threadsRequestedSinceLastCheck;
-- _threadsEaten;
// 从线程池夺取一个线程
if (m_freeThreads.size()) // 有可用线程
{
// 得到一个可用线程
t = * m_freeThreads.begin();
// 把它从可用线程对列里删掉
m_freeThreads.erase(m_freeThreads.begin());
// 给这个线程一个任务
t -> ExecutionTarget = ExecutionTarget;
// 恢复线程的执行
t -> ControlInterface.Resume();
}
else
{
// 创建一个新的线程并执行任务
t = StartThread(ExecutionTarget);
}
// 把线程加到执行任务线程对列
m_activeThreads.insert(t);
_mutex.Release();
}
void CThreadPool::Startup()
{
int i;
int tcount = 5 ;
for (i = 0 ; i < tcount; ++ i)
StartThread(NULL);
}
void CThreadPool::ShowStats()
{
_mutex.Acquire();
// 在这里输出线程池的状态
//
_mutex.Release();
}
void CThreadPool::KillFreeThreads(uint32 count)
{
_mutex.Acquire();
Thread * t;
ThreadSet::iterator itr;
uint32 i;
for (i = 0 , itr = m_freeThreads.begin(); i < count && itr != m_freeThreads.end(); ++ i, ++ itr)
{
t = * itr;
t -> ExecutionTarget = NULL;
t -> DeleteAfterExit = true ;
++ _threadsToExit;
t -> ControlInterface.Resume();
}
_mutex.Release();
}
void CThreadPool::Shutdown()
{
_mutex.Acquire();
size_t tcount = m_activeThreads.size() + m_freeThreads.size();
KillFreeThreads((uint32)m_freeThreads.size());
_threadsToExit += (uint32)m_activeThreads.size();
for (ThreadSet::iterator itr = m_activeThreads.begin(); itr != m_activeThreads.end(); ++ itr)
{
if (( * itr) -> ExecutionTarget)
( * itr) -> ExecutionTarget -> OnShutdown();
}
_mutex.Release();
for (;;)
{
_mutex.Acquire();
if (m_activeThreads.size() || m_freeThreads.size())
{
_mutex.Release();
Sleep( 1000 );
continue ;
}
break ;
}
}
static unsigned long WINAPI thread_proc( void * param)
{
Thread * t = (Thread * )param;
t -> SetupMutex.Acquire();
uint32 tid = t -> ControlInterface.GetId();
bool ht = (t -> ExecutionTarget != NULL);
t -> SetupMutex.Release();
for (;;)
{
if (t -> ExecutionTarget != NULL)
{
if (t -> ExecutionTarget -> run()) // 执行任务,返回true表示任务完成
delete t -> ExecutionTarget;
t -> ExecutionTarget = NULL;
}
if ( ! ThreadPool.ThreadExit(t))
{
// Log.Debug("ThreadPool", "Thread %u exiting.", tid);
break ;
}
else
{
// if(ht)
// printf("ThreadPool:线程%d正在等待新任务.", tid);
t -> ControlInterface.Suspend(); // 暂停线程运行
}
}
ExitThread( 0 );
return 0 ;
}
Thread * CThreadPool::StartThread(ThreadBase * ExecutionTarget)
{
HANDLE h;
Thread * t = new Thread;
t -> DeleteAfterExit = false ;
t -> ExecutionTarget = ExecutionTarget;
t -> SetupMutex.Acquire();
/*
CreateThread(
lpThreadAttributes是线程的属性,
dwStackSize是线程的栈大小,
lpStartAddress是线程函数的开始地址,
lpParameter是传送给线程函数的参数,
dwCreationFlags是创建线程标志，比如挂起线程,
lpThreadId是标识这个线程的ID)
*/
h = CreateThread(NULL, 0 , & thread_proc, (LPVOID)t, 0 , (LPDWORD) & t -> ControlInterface.thread_id);
t -> ControlInterface.Setup(h);
t -> SetupMutex.Release();
return t;
}