线程管理与封装代码,C代码库,德仔网

代码语言

代码分类

【C】线程管理与封装

作者:Dezai.CN / 发布于2011/8/31/ 523

在进行编程时，难免会进行多线程的操作，win32 api使用起来诸多不便，因此我用C++封装了一下。包含：线程基类Thread 线程组管理ThreadManager 临界区锁CriticalSection 当然实际运用中不可能只有这点，大家根据需要自己加代码完成吧。比如事件锁，互斥锁，信号锁等等

#include <windows.h>
#include <iostream>
#include <string>
#include <vector>
#include <process.h>
#include <assert.h></div>
<div>// Thread.h --------------------------------------</div>
<div>/* 线程封装 */
class Thread
{
public:
typedef unsigned long handle_t;
typedef unsigned ( __stdcall * start_routine )( void * param );
bool want_stop;
bool auto_delete;
unsigned thread_id;
unsigned exit_code;</div>
<div>Thread( void );
virtual ~Thread( void );
virtual void run() = 0;</div>
<div>void start( void );
void pause( void );
void close( void );
void wait( unsigned long ms = INFINITE );
void forceStop( void );</div>
<div>handle_t handle( void ) { return _thread; }
private:
handle_t _thread;
static unsigned __stdcall _start_run( Thread * thread_ptr );</div>
<div>Thread( Thread const & );
Thread & operator = ( Thread const & );
};</div>
<div>// Thread.cpp ------------------------------------
Thread::Thread( void ) : _thread(0), thread_id(0), want_stop(false), auto_delete(true), exit_code(0)
{
_thread = _beginthreadex( NULL, 0, (start_routine)_start_run, this, CREATE_SUSPENDED, &this->thread_id );
}
<div>Thread::~Thread( void )
{
this->close();
}
<div>void Thread::start( void )
{
ResumeThread( (HANDLE)_thread );
}
<div>void Thread::pause( void )
{
SuspendThread( (HANDLE)_thread );
}
<div>void Thread::close( void )
{
if ( _thread )
{
CloseHandle( (HANDLE)_thread );
_thread = 0;
}
}
<div>void Thread::wait( unsigned long ms /*= INFINITE */ )
{
WaitForSingleObject( (HANDLE)_thread, ms );
}
<div>unsigned __stdcall Thread::_start_run( Thread * thread_ptr )
{
thread_ptr->run();
unsigned exit_code = thread_ptr->exit_code;</div>
if ( thread_ptr->auto_delete )
delete thread_ptr;</div>
<div>return exit_code;
}
<div>void Thread::forceStop( void )
{
TerminateThread( (HANDLE)_thread, exit_code );
}
<div>// ThreadManager.h ----------------------------------------
/* 线程管理器 */
template <typename _Thread> class ThreadManager
{
public:
 typedef typename std::vector<_Thread *> thread_array;</div>
<div>ThreadManager( void ) {}
~ThreadManager( void )
{
thread_array::iterator it;
for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
{
delete *it;
}
_thread_arr.clear();
}
template <typename _ARG_T1> void create( int count, _ARG_T1 arg1 )
{
int i;
for ( i = 0; i < count; i++ )
{
_Thread * th_ptr = new _Thread(arg1);
th_ptr->auto_delete = false;
_thread_arr.push_back(th_ptr);
}
}
template < typename _ARG_T1, typename _ARG_T2 > void create( int count, _ARG_T1 arg1, _ARG_T2 arg2 )
{
int i;
for ( i = 0; i < count; i++ )
{
_Thread * th_ptr = new _Thread( arg1, arg2 );
th_ptr->auto_delete = false;
_thread_arr.push_back(th_ptr);
}
}
template < typename _ARG_T1, typename _ARG_T2, typename _ARG_T3> void create( int count, _ARG_T1 arg1, _ARG_T2 arg2, _ARG_T3 arg3 )
{
int i;
for ( i = 0; i < count; i++ )
{
_Thread * th_ptr = new _Thread( arg1, arg2, arg3 );
th_ptr->auto_delete = false;
_thread_arr.push_back(th_ptr);
}
}
void create( int count )
{
int i;
for ( i = 0; i < count; i++ )
{
_Thread * th_ptr = new _Thread();
th_ptr->auto_delete = false;
_thread_arr.push_back(th_ptr);
}
}
void start( void )
{
thread_array::iterator it;
for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
{
(*it)->start();
}
}
void pause( void )
{
thread_array::iterator it;
for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
{
(*it)->pause();
}
}
void close( void )
{
thread_array::iterator it;
for ( it = _thread_arr.begin(); it != _thread_arr.end(); it++ )
{
(*it)->close();
}
}
void wait( unsigned long ms = INFINITE )
{
int count = _thread_arr.size();
assert( count <= MAXIMUM_WAIT_OBJECTS );
HANDLE * th_hs = new HANDLE[count];
int i;
for ( i = 0; i < count; ++i )
{
th_hs[i] = (HANDLE)_thread_arr[i]->handle();
}
WaitForMultipleObjects( count, th_hs, TRUE, ms );
delete [] th_hs;
}
private:
thread_array _thread_arr;</div>
<div>ThreadManager( ThreadManager const & );
ThreadManager & operator = ( ThreadManager const & );
};</div>
<div>// Lock.h -----------------------------------------------------
/* 临界区锁 */
class CriticalSection
{
public:
CriticalSection( void );
~CriticalSection( void );
void lock( void );
void unlock( void );
bool trylock( void );
private:
CRITICAL_SECTION _cs;</div>
<div>CriticalSection( CriticalSection const & );
CriticalSection & operator = ( CriticalSection const & );
};</div>
<div>// Lock.cpp -----------------------------------------------------
CriticalSection::CriticalSection( void )
{
ZeroMemory( &_cs, sizeof(_cs) );
InitializeCriticalSection(&_cs);
}
<div>CriticalSection::~CriticalSection( void )
{
DeleteCriticalSection(&_cs);
}
<div>void CriticalSection::lock( void )
{
EnterCriticalSection(&_cs);
}
<div>void CriticalSection::unlock( void )
{
LeaveCriticalSection(&_cs);
}
<div>bool CriticalSection::trylock( void )
{
return TryEnterCriticalSection(&_cs);
}
<div>// Test.cpp --------------------------------------------------------
/*自定义一个线程*/
class MyThread : public Thread
{
public:
MyThread( CriticalSection * cs_lock ) : _cs_lock(cs_lock)
{
}
MyThread( CriticalSection * cs_lock, std::string name ) : _cs_lock(cs_lock), _name(name)
{
}
virtual void run()
{
int i = 0;
while ( !this->want_stop && i++ < 100 )
{
_cs_lock->lock();
std::cout << _name << " " << this->thread_id << " 正在运行...\n";
_cs_lock->unlock();
}
}
private:
CriticalSection * _cs_lock;
std::string _name;
};</div>
<div>
int main()
{
std::string cmd;
CriticalSection cs;
class MyThreadOnce : public Thread
{
public:
MyThreadOnce( CriticalSection * cs ) : _cs(cs) {}
~MyThreadOnce( void )
{
_cs->lock();
std::cout << this->thread_id << " 析构！\n";
_cs->unlock();
}
virtual void run()
{
_cs->lock();
std::cout << this->thread_id << " 运行完毕！\n";
_cs->unlock();
}
private:
CriticalSection * _cs;
};</div>
<div>// 启动一个线程，运行完毕自动析构
(new MyThreadOnce(&cs))->start();</div>
<div>// 管理一组线程，调用create()函数创建线程，可最多传3个参数调用构造函数
ThreadManager<MyThread> mgr;
mgr.create( 5, &cs );
mgr.create( 5, &cs, std::string("Output") );
mgr.start();

// 接受用户输入
while ( std::cin >> cmd )
{
if ( cmd == "stop" )
{
break;
}
}
<div> return 0;
}
</div>

评论列表

本站所提供的代码，版权归原作者所有，若有侵犯作者版权，请与我们联系，我们将立即删除或修改。谢谢!
本站所有代码发布及提供者。

试试其它关键字

　线程管理　

同语言下

可能有用的

Dezai.CN贡献的其它代码(4037)