thread.cpp.bak

网络socket,IO,线程池

#include "Thread.h"
using namespace Thread;

////////////////////////////////////////////////////////////////////////////
// Constructors / Destructor                                              //
////////////////////////////////////////////////////////////////////////////
	
// Constructor
ThreadBase::ThreadBase(void) : m_thread(NULL),m_threadID(0) 
{
}

// Destructor
ThreadBase::~ThreadBase()
{
}

////////////////////////////////////////////////////////////////////////////
// Implemetation		                                          //
////////////////////////////////////////////////////////////////////////////

int ThreadBase::Start(ThreadFunc func,void * arg,int nStackSize,int nPriority)
{
	
	ThreadBase * pThread = reinterpret_cast<ThreadBase *>(arg);

	
	int nVal = _beginthreadex(0, nStackSize, func, arg, 0, &pThread->m_threadID);
	if (nVal > 0)
	{	
		pThread->m_thread = reinterpret_cast<void*>(nVal);
		SetThreadPriority(reinterpret_cast<HANDLE>(pThread->m_thread),nPriority);
		return 0;
	}
    	return -1;
}

////////////////////////////////////////////////////////////////////////////
// Constructors / Destructor                                              //
////////////////////////////////////////////////////////////////////////////
	
// Constructor
thread::thread() : ThreadBase(),m_nThreadResult(-1),m_bWantExit(false)
{
	
}

// Destructor
Thread::~Thread(void)
{
	StopEx();
}

////////////////////////////////////////////////////////////////////////////
// Operations		                                                  //
////////////////////////////////////////////////////////////////////////////
void Thread::StartEx(int nStackSize,int nPriority) throw(MException)
{
	int res = ThreadBase::Start(ThreadProxy,this,nStackSize,nPriority);
	if (res != 0)
		throw MException(THREAD_START_ERROR,"Start Thread Error");	
}

void Thread::Stop(void)
{
	m_bWantExit = true;
}

int Thread::StopEx(void)
{
	Stop();
	return WaitUntilStop();
}

int Thread::WaitUntilStop(void)
{	
	WaitForSingleObject(m_evHasExit,INFINITE);
	return m_nThreadResult;
}


unsigned __stdcall Thread::ThreadProxy(void * arg)
{
	Thread * pThread = reinterpret_cast<Thread *>(arg);

	pThread->m_nThreadResult = -1;
	try
	{
		// 线程执行任务
		pThread->m_nThreadResult = pThread->Run();		
	}
	
	catch(CException& e)
	{
		OnException(e);
	}

	m_evHasExit.SetEvent();	
	OnDelete();

	return 0;
}