www.pudn.com > cxThread.zip > cxThread.h

/* 
thread (WIN32)	 
 
Compile by£º BC++ 5; C++ BUILDER 4, 5, 6, X; VC++ 5, 6; VC.NET;  GCC; 
 
Update : 2004.11 
 
copyright(c) 2004.5 - 2004.11  llbird wushaojian@21cn.com 
*/ 
 
#ifndef _CX_THREAD_H_ 
#define _CX_THREAD_H_ 
 
#include  
#include  
#include  
 
 
 
//------------------------------class cxLocker----------------------------------- 
 
class cxLocker 
{ 
	CRITICAL_SECTION _csLock; 
public: 
	cxLocker() 						{		::InitializeCriticalSection(&_csLock);		} 
	~cxLocker()						{		::DeleteCriticalSection(&_csLock);			} 
	operator CRITICAL_SECTION*()	{		return  &_csLock;							} 
	void Lock()						{		::EnterCriticalSection(&_csLock);			} 
	void UnLock()					{		::LeaveCriticalSection(&_csLock);			} 
}; 
 
//------------------------------class cxLock----------------------------------- 
 
class cxLock 
{ 
	CRITICAL_SECTION* _pLock; 
public: 
	explicit cxLock(CRITICAL_SECTION * p) : _pLock(p)	{	::EnterCriticalSection(_pLock);		} 
	~cxLock()											{	::LeaveCriticalSection(_pLock);		} 
}; 
 
 
//------------------------------class cxEvent----------------------------------- 
 
class cxEvent 
{ 
	HANDLE _hEvent; 
	cxEvent(const cxEvent&); 
	cxEvent& operator = (const cxEvent& x); 
public: 
 
//------------------------------Construction----------------------------------- 
	 
	cxEvent(HANDLE Event) : _hEvent(Event) 
	{ 
	} 
 
	cxEvent(char *pName) : _hEvent(Create(NULL, FALSE, FALSE, pName))	 
	{ 
	}   
 
	cxEvent( 
		LPSECURITY_ATTRIBUTES  lpEventAttributes = NULL,  
		BOOL bManualReset = FALSE, 
		BOOL bInitialState = FALSE,  
		char *pName = NULL 
		) : _hEvent(Create(lpEventAttributes, bManualReset, bInitialState, pName)) 
	{ 
	} 
 
	~cxEvent()				 
	{ 
		if(_hEvent)	 
			::CloseHandle(_hEvent);												 
	} 
	 
//----------------------------------Attributes---------------------------------- 
 
	operator HANDLE()	{		return _hEvent;					} 
	bool IsValid()		{		return _hEvent != NULL;			} 
 
//----------------------------------Operations---------------------------------- 
	 
	HANDLE Create( 
		LPSECURITY_ATTRIBUTES  lpEventAttributes = NULL,  
		BOOL bManualReset = FALSE, 
		BOOL bInitialState = FALSE,  
		char *pName = NULL 
		) 
	{ 
		HANDLE hTemp = ::CreateEvent(lpEventAttributes, bManualReset, bInitialState, pName); 
		THROW_ERROR(hTemp == NULL); 
		return hTemp; 
	} 
 
	bool Wait(DWORD dwWaitTime = INFINITE)	 
	{ 
		return ::WaitForSingleObject(_hEvent, dwWaitTime) == WAIT_OBJECT_0; 
	} 
 
	void Lock() 
	{ 
		::WaitForSingleObject(_hEvent, INFINITE); 
	} 
 
    BOOL Reset()		{		return ::ResetEvent(_hEvent);	} 
    BOOL Set()			{		return ::SetEvent(_hEvent);		} 
    BOOL Pulse() 		{		return ::PulseEvent(_hEvent);	} 
}; 
 
//------------------------------class cxThread----------------------------------- 
 
class cxThread  
{ 
private: 
 
	static DWORD WINAPI DefaultThreadProc(LPVOID lpPara) 
	{ 
		return ( (cxThread *)lpPara ) -> ThreadProc(); 
	} 
	cxThread(const cxThread&); 
	cxThread& operator = (const cxThread& x); 
	cxLocker _ThreadLocker; 
 
protected: 
 
	virtual DWORD ThreadProc()		{		return 0;												}  
	HANDLE _hThreadHandle; 
	DWORD _dwThreadID; 
 
public: 
 
//------------------------------Construction----------------------------------- 
 
	cxThread()						{		_hThreadHandle = NULL, _dwThreadID = 0;					} 
	virtual ~cxThread()				{		Terminate();											} 
 
//----------------------------------Attributes---------------------------------- 
 
	operator HANDLE() 				{	 	return _hThreadHandle;									} 
	const HANDLE GetThreadHandle()	{		return _hThreadHandle;									} 
	const DWORD GetThreadID()	 	{		return _dwThreadID;										} 
	bool IsRunning()				{		return _hThreadHandle != NULL;						 	} 
	BOOL GetPriority()				{		return GetThreadPriority(_hThreadHandle) ;				} 
	BOOL SetPriority(int iPriority)	{		return SetThreadPriority(_hThreadHandle, iPriority);	} 
 
//----------------------------------Operations---------------------------------- 
 
	inline void Lock()				{		_ThreadLocker.Lock();									} 
	inline void UnLock()			{		_ThreadLocker.UnLock();									} 
 
	inline bool virtual Begin(DWORD dwCreationFlags = 0)  // Begin equal run 
	{		 
		return Run(dwCreationFlags);	 
	} 
 
	inline bool virtual Begin(LPTHREAD_START_ROUTINE threadProc, LPVOID lpPara = NULL, DWORD dwCreationFlags = 0) 
	{ 
		return Run(threadProc, lpPara, dwCreationFlags); 
	} 
		 
	bool virtual Run(DWORD dwCreationFlags = 0) 
	{ 
		if(IsRunning()) 
			Stop(); 
 
		_hThreadHandle = CreateThread(NULL, 0, cxThread::DefaultThreadProc, this, dwCreationFlags, &_dwThreadID); 
 
		THROW_ERROR(_hThreadHandle == NULL); 
 
		return  IsRunning(); 
	}; 
 
	bool virtual Run(LPTHREAD_START_ROUTINE threadProc, LPVOID lpPara = NULL, DWORD dwCreationFlags = 0) 
	{ 
		assert(threadProc != NULL); 
 
		if(IsRunning()) 
			Stop(); 
 
		_hThreadHandle = CreateThread(NULL, 0, threadProc, lpPara, dwCreationFlags, &_dwThreadID); 
 
		THROW_ERROR(_hThreadHandle == NULL); 
 
		return  IsRunning(); 
	}; 
 
#ifdef  _MT 
 
	inline bool virtual Begin(void( __cdecl *threadProc )( void * ), LPVOID lpPara = NULL) 
	{ 
		return Run(threadProc, lpPara); 
	} 
 
	inline bool virtual Begin(unsigned ( __stdcall *threadProc )( void * ), LPVOID lpPara = NULL, DWORD dwCreationFlags = 0) 
	{ 
		return Run(threadProc, lpPara, dwCreationFlags); 
	}  
 
	bool virtual Run(void( __cdecl *threadProc )( void * ), LPVOID lpPara = NULL) 
	{ 
		assert(threadProc != NULL); 
 
		if(IsRunning()) 
			Stop(); 
 
		_hThreadHandle = (HANDLE)_beginthread(threadProc, 0, lpPara); 
 
		if(_hThreadHandle == (HANDLE) -1L) 
			_hThreadHandle = NULL; 
 
		THROW_ERROR(_hThreadHandle == NULL); 
 
		return  IsRunning(); 
	}; 
 
	bool virtual Run(unsigned ( __stdcall *threadProc )( void * ), LPVOID lpPara = NULL, DWORD dwCreationFlags = 0) 
	{ 
		assert(threadProc != NULL); 
 
		if(IsRunning()) 
			Stop(); 
 
		_hThreadHandle = (HANDLE)_beginthreadex(NULL, 0, threadProc, lpPara, dwCreationFlags, (unsigned int *)&_dwThreadID); 
 
		THROW_ERROR(_hThreadHandle == NULL); 
 
		return  IsRunning(); 
	}; 
	 
#endif	 // _MT 
 
	inline void virtual End(DWORD dwEndCode = 0) 
	{ 
		Terminate(dwEndCode); 
	} 
 
	void virtual Terminate(DWORD dwEndCode = 0) 
	{ 
		if(IsRunning()) 
		{ 
			TerminateThread(_hThreadHandle, dwEndCode); 
			CloseHandle(_hThreadHandle); 
			_hThreadHandle = NULL; 
		} 
	} 
 
	void virtual Stop(DWORD dwEndCode = 0) 
	{ 
		Terminate(dwEndCode); 
	} 
 
	bool WaitFor(DWORD dwWaitTime = INFINITE)	//Wait the Thread Auto Terminate in (dwWaitTime) 
	{ 
		return WaitForSingleObject(_hThreadHandle, dwWaitTime) == WAIT_OBJECT_0; 
	} 
 
	virtual bool Suspend() 
	{ 
		return SuspendThread(_hThreadHandle) != (DWORD)(-1L); 
	} 
 
	virtual bool Resume() 
	{ 
		return ResumeThread(_hThreadHandle) != (DWORD)(-1L); 
	} 
	 
} ; 
 
#endif //_CX_THREAD_H_