A Method of Worker Thread Pooling

// ThNode.cpp: implementation of the CThNode class.
// Author : Pradeep Kumar Sahu
// Email  : sahupk@yahoo.com
// Note   : It will be greaet to receive your feedback and any bugs that 
//          are found.
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ThreadPool.h"
#include "Thread.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#define STOP_WORKING -1
#define KEEP_WORKING  0

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//UINT ThreadFunction(LPVOID );
CCriticalSection  CThread::m_threadCS;

CThread::CThread(CThPool *pPool)
{
	//Start the thread 
	this->m_pPool = pPool;
	this->m_pTarget = NULL;
	this->m_pThread = AfxBeginThread(ThreadFunction,this);
	this->m_flag = KEEP_WORKING;		
}



CThread::~CThread()
{	
	if(this->m_pThread != NULL )
	{
		this->m_pThread->ExitInstance();
	}

}

void CThread::stop()
{
	this->m_flag = STOP_WORKING;
	this->m_pThread->ResumeThread();

}
//Thread creation function

UINT CThread::ThreadFunction(LPVOID pParam)
{
	CSingleLock singleLock(&m_threadCS);			
	CThread *pThread = (CThread *)pParam;
	pThread->m_flag =1;
	::Sleep(1);
	//pThread->mp_thread->SuspendThread();
	while(pThread->m_flag !=STOP_WORKING )
	{
		//Do the work if the target is not null;
		if(pThread->m_pTarget !=  NULL)
		{
			pThread->m_pTarget->run();
			//If auto delete set in the target then destroy the target
			if(pThread->m_pTarget->AutoDelete())
				delete pThread->m_pTarget;			
			pThread->m_pTarget = NULL;			
		}
		//Add the free thread to the pool
		if(pThread->m_pPool == NULL) break;
		singleLock.Lock();
		if(pThread->m_pPool->getCurPoolSize() <= pThread->m_pPool->getMaxFreePoolSize())
		{
			pThread->m_pPool->addFreeThread(pThread);	
			//As the current work is complete so suspend the thread.
			singleLock.Unlock();
			pThread->m_pThread->SuspendThread();			
		}
		else
		{
			//delete this thread as already the max size limit is crossed
			pThread->stop();
			singleLock.Unlock();
		}		
	}
	//If the pool is not null then call delete the thread.
	if(pThread->m_pPool != NULL) 
	{
		pThread->m_pPool->deleteThread(pThread);
	}
	else 
	{    //As the thread pThread does not  belong to any pool then delete the thread here as 
		 //the POOL can not clear this memory
		delete pThread;
	}		
	return 0;
}


BOOL CThread::isFree()
{
	if(this->m_pTarget == NULL)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}


void CThread::setTarget(CThTarget *pTarget)
{
	this->m_pTarget = pTarget;
	//Now the thread should be resumed to process the target
	::Sleep(0);
	this->m_pThread->ResumeThread();
	
}

void CThread::setPool(CThPool *pPool)
{
	this->m_pPool = NULL;
}