我自己的线程类, 比mfc的那个简单,灵活

王朝c/c++·作者佚名  2006-01-09
窄屏简体版  字體: |||超大  

这是范例, 头文件在后边

#pragma warning(disable: 4530)

#pragma warning(disable: 4786)

#include <cassert>

#include <iostream>

#include <exception>

#include <algorithm>

#include <math.h>

#include <iomanip>

using namespace std;

#include <winsock2.h>

#include <windows.h>

#include "cxThread.h"

cxLocker coutLock; //输出的锁

int comp(const void *a, const void *b)

{

return *(char*)a - *(char*)b;

}

void dos_sort_func(void *p)

{

cxLock lock(coutLock); //生存期自动锁, 不需要UnLock();

char *t = new char[strlen((char *)p) + 1];

strcpy(t, (char *)p);

qsort(t, strlen(t), 1, comp);

cout << (char *)t << endl;

delete t;

}

DWORD WINAPI win_sort_func(LPVOID p)

{

cxLock lock(coutLock);

char *t = new char[strlen((char *)p) + 1];

strcpy(t, (char *)p);

sort(t, t + strlen((char *)t));

cout << (char *)t << endl;

delete t;

return 0;

}

class MyThread : public cxThread

{

char buf[20];

protected:

virtual DWORD ThreadProc()

{

cxLock lock(coutLock);

sort(buf, buf + strlen((char *)buf));

cout << buf << endl;

return 0;

}

public:

MyThread()

{

strcpy(buf, "xdeefde");

}

};

int main(int argc, char *argv[])

{

try

{

char buf[] = "adceafeadb";

cxThread mt;

MyThread myt;

mt.Run(dos_sort_func, buf); //调用dos风格的函数

mt.Wait();

mt.Run(win_sort_func, buf); //调用windows风格的函数

mt.Wait();

myt.Run(); //调用自定义的虚函数

myt.Wait();

}

catch(exception *e)

{

cout << e->what() << endl;

}

return 0;

}

//-----------------------------------------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 <assert.h>

#include <process.h>

#include <windows.h>

//------------------------------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);

return hTemp;

}

bool Wait(DWORD dwWaitTime = INFINITE)

{

return ::WaitForSingleObject(_hEvent, dwWaitTime) == WAIT_OBJECT_0;

}

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);

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);

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;

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);

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 Wait(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_

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
 
 
© 2005- 王朝網路 版權所有 導航