不到300行的简单线程池C++实现 - c++编程基础

Pool& Pool)
:mPool (Pool),
mThreadID (0),
mCurrJob (NULL),
mIsDie (false)
{
mHandle = CreateThread (
NULL,
0,
Routine,
this,
0,
&mThreadID
);
if (NULL == mHandle) {
throw ThreadException ("CreateThread Failed");
}
}

Thread::~Thread()
{
}

void
Thread::Attach (Job* _Job)
{
LockGuide Guide (mLock);

mCurrJob = _Job;
mSignal.WakeUp();
}

void
Thread::Die()
{
mLock.Enter();

mIsDie = true;
mSignal.WakeUp();
mLock.Leave();
mDieSignal.Wait();

}

DWORD
Thread::Routine (LPVOID Parameter)
{
Thread* _Thread = static_cast (Parameter);
while (true) {
_Thread->mSignal.Wait();

/// 检查线程是否需要退出
_Thread->mLock.Enter();
if (_Thread->mIsDie) {
_Thread->mLock.Leave();
break;
}
_Thread->mLock.Leave();

/// 干活
_Thread->mCurrJob->Do();

/// 干完活,回到IDLE状态
_Thread->mLock.Enter();
_Thread->mCurrJob = NULL;
_Thread->mPool.Put (_Thread);
_Thread->mLock.Leave();

}

_Thread->mDieSignal.WakeUp();
return 0;
}

#undef _CLASS_
#define _CLASS_ "ThreadPool"

ThreadPool::ThreadPool()
{
}

ThreadPool::~ThreadPool()
{
Release();
}

bool
ThreadPool::Alloc (unsigned int ThreadNum)
{
LockGuide Guide(mKeeper);
try {
for (unsigned int N = 0; N < ThreadNum; ++N) {
mIdleThreads.push_back(new Thread (*this));
}
} catch (const ThreadException& e) {
return false;
}
return true;
}

void
ThreadPool::Release()
{
LockGuide Guide(mKeeper);

/// 编程上的要求:
/// 释放线程池之前必须先让所有Thread进入Idle状态
/// 这样才不用强制Kill掉线程
assert(mBusyThreads.empty());

while (!mIdleThreads.empty()) {
Thread* _Thread = mIdleThreads.front();
_Thread->Die();
delete _Thread;
mIdleThreads.pop_front();
}
}

Thread*
ThreadPool::Get()
{
LockGuide Guide (mKeeper);
if (!mIdleThreads.empty()) {
Thread* _Thread = mIdleThreads.front();
mIdleThreads.pop_front();
mBusyThreads.push_back(_Thread);
return _Thread;
}
return NULL;
}

void
ThreadPool::Put (Thread* _Thread)
{
LockGuide Guide (mKeeper);
mBusyThreads.remove(_Thread);
mIdleThreads.push_back(_Thread);
}

bool
ThreadPool::IsBusy()
{
LockGuide Guide (mKeeper);
return !mBusyThreads.empty();
}

摘自最大的敌人是自己

不到300行的简单线程池C++实现(二)