test.cpp

用vc++写的一个简单的线程池的代码

// test.cpp : Defines the entry point for the console application.
// Author - [e-mail]

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


//Dummy class for test- can be any class


class CTask
{

CString m_szTaskName;
CString  szBMMLString;
CString  m_strLoggingTerminal;
CString  m_strLoggingUser;

public:

	CTask(){};

	CTask(int i):nClassId(i)
		
	{
		m_szTaskName ="DISPALARM";
		szBMMLString ="DISPALARM";
//		printf("CTask Created Id=%d\n",nClassId);
	};

	~CTask(){};


	void HandleSuccess()
	{
		printf("Inside HandleSuccess of %d\n",nClassId);
		/*if( (nClassId % 3) ==0) //for test of hanging tasks
		{
			printf("Going to sleep!!\n");
			Sleep(10000);
		}
		else
		{
			Sleep(100);
		}
		*/
		Sleep(100);
		printf("Outof HandleSuccess %d\n",nClassId);
	
	}

	void HangCommand()
	{
		printf("Going to hang\n");
		Sleep(INFINITE);
	}

	void HandleFailure()
	{
		printf("Inside HandleFailure\n");
	}

	void SleepTask()
	{
		printf("Inside SleepTask\n");
		Sleep(INFINITE);
	}


	void  VoidReturnTask(void)
	{

		printf("Inside VoidReturnTaskof %d\n",nClassId);
		return ;
	}


	int  NoParameterTask(void)
	{
		printf("Inside NoParameterTask %d\n",nClassId);
		return  1;
	}

	
	int OneParameterTask(int par1)
	{
	
		printf("Inside  OneParameterTask result is %d\n",par1);
		return par1;
	}

	int TwoParamterTask(int par1, int par2)
	{
		int result = par1 * par2;
		printf("Inside  TwoParamterTask result is %d\n",result);
		return result;
	}

	int ThreeParameterTask(int par1, int par2, int par3)
	{
		int result = par1 * par2 * par3;
		printf("Inside ThreeParameterTask  result is %d\n",result);
		return result;
	}

	unsigned long GetTimeOut()
	{
		return 5; //in seconds
	}
private:

	int nClassId;
	
};


//typedef void (CTask::*F)();								// typedef the function signature void func (void)
typedef void (CTask::*F)();								// typedef the function signature int func (int)

typedef PluginThreadPool::binder<								//function adapter - binary function to unary function	
						std::mem_fun_t<int,CTask>,		//member function adapter ->member function to function object
						CTask* > F0;					//int fun(void)

typedef std::binder1st<											//function adapter - binary function to unary function
						std::mem_fun1_t<int,CTask,int>  //member function adapter ->member function to function object
						 > F1;							// int fun (int)

typedef PluginThreadPool::binder3<											//function adapter - binary function to unary function
//						std::mem_fun1_t<int,CTask,int,int,int>  / wont work here /member function adapter ->member function to function object
		PluginThreadPool::mem_fun3_t<int,CTask,int,int,int> , //member function adapter ->member function to function object
				CTask* ,int,int,int		 > F3;							// int fun (int)



using namespace PluginThreadPool ;

HANDLE hEvent ;

UINT SecondThread(LPVOID param);

//Okay here is out threadpool implementation
ThreadPool<CTask> t1(5,10,12);


void main( void ) 
{
	hEvent = CreateEvent(0,1,0,0);
	SetEvent(hEvent);
	//Create a thread that will monitor the pending jobs
	CWinThread*	winthread = AfxBeginThread(SecondThread,0,0,0,CREATE_SUSPENDED);
	winthread->m_bAutoDelete = FALSE;
	winthread->ResumeThread();
	

	//A no parameter task return type is also void
	CTask *task1 = new CTask(1);
	F f= &CTask::VoidReturnTask;
	((*task1).*f)();


	
	//	F0 f0 = PluginThreadPool::bind(std::mem_fun1(&CTask::VoidReturnTask), task1 );//wont work since expected signature is int func(...)
	F0 f0 = PluginThreadPool::bind(std::mem_fun(&CTask::NoParameterTask), task1 );
	f0();

	F1 f1 = std::bind1st( std::mem_fun1( &CTask::OneParameterTask), task1 );
	f1(1);

	F3 f3 = PluginThreadPool::bind3( PluginThreadPool::mem_fun3( &CTask::ThreeParameterTask), task1,10,11,12 );
	f3();//better

	printf("Size of unsig int=%u\n",sizeof(unsigned int));

	try
	{

		//int i=0; while(1)
		for(int i=0; i<10;/*++i*/)
		{
			++i;
			CTask *task1 = new CTask(i);
			Command<CTask>* cmd =0;
					
			F0 f0 = PluginThreadPool::bind(std::mem_fun(&CTask::NoParameterTask), task1 );
			cmd= new Command<CTask>(task1,&f0,task1->GetTimeOut(),"ne2_11",PluginThreadPool::PRIO_NORMAL);
			t1.QueueRequest(cmd);

			F1 f1 = std::bind1st( std::mem_fun1( &CTask::OneParameterTask), task1 );
			cmd= new Command<CTask>(task1,&f1,10,task1->GetTimeOut(),"ne2_11",PluginThreadPool::PRIO_NORMAL);
			t1.QueueRequest(cmd);

			F3 f3 = PluginThreadPool::bind3( PluginThreadPool::mem_fun3( &CTask::ThreeParameterTask), task1,2,3,4 );
			cmd= new Command<CTask>(task1,&f3,task1->GetTimeOut(),"ne2_11",PluginThreadPool::PRIO_NORMAL);
			t1.QueueRequest(cmd);


		
			Sleep(1000);
	
		}
		

	}
	catch(...)
	{
		printf("Exception Caught in Main Thread.....\n");
		throw;
	}

	Sleep(INFINITE);
	WaitForSingleObject(hEvent,INFINITE);
	printf("Main Thread Over\n");

	return;
}

UINT SecondThread(LPVOID param)
{
	//SetEvent(hEvent);

	try
	{
		//for(int i=100000; i<=200000;++i)
		while(1)
		{
			CTask *task1 = new CTask(999);
			Command<CTask>* cmd= new Command<CTask>(task1,&CTask::VoidReturnTask,task1->GetTimeOut(),"ne1" );
			t1.QueueRequest(cmd);
			Sleep(50);

		}
	
	}
	catch(...)
	{
		printf("Exception Caught IN SecondThread.....\n");
		throw;
	}
	Sleep(INFINITE);
	ResetEvent(hEvent);

	return 1;
};