Pthread实现面向对象的线程处理简单框架

#ifndef _THREAD_RUNNER_H_
#define _THREAD_RUNNER_H_
#include <pthread.h>
#include <string.h>
namespace acceptor_common
{
namespace utility
{
#define MAX_THREAD_NUMBER 128

class Runner;

class ThreadRunner
{
public:
ThreadRunner();

int start(int threadNumer , Runner * runner);
int stop(int counter = -1);
int wait();
private:
pthread_t _threadId[MAX_THREAD_NUMBER];
int _threadNumber;
};
class Runner
{
public:
Runner();
virtual ~Runner();

int start(int threadNumber);
int stop();
int wait();

virtual int run();
private:
ThreadRunner * _runner;
};
}
}
#endif

#include "ThreadRunner.h"
using namespace acceptor_common::utility;
void * start_thread(void * args)
{
Runner * runner = (Runner *)args;
runner->run();
return 0;
}
ThreadRunner::ThreadRunner()
{
memset(_threadId , 0x00 , sizeof(pthread_t) * MAX_THREAD_NUMBER);
_threadNumber = 0;
}
int ThreadRunner::start(int threadNumber , Runner * runner)
{
if (threadNumber > MAX_THREAD_NUMBER)
return -1;
int ret = 0;
for (int i = 0;i < threadNumber ; i++ )
{
if (pthread_create(&_threadId[i] , 0 , start_thread , runner) != 0)
{
ret = -1;
stop(i);

break;
}
}
_threadNumber = threadNumber;

return ret;
}

int ThreadRunner::stop(int counter)
{
int total = counter;
if (total == -1)
total = _threadNumber;

for (int i = 0;i < total; i ++)
pthread_cancel(_threadId[i]);
_threadNumber = 0;
memset(_threadId , 0x00 , sizeof(pthread_t) * MAX_THREAD_NUMBER);

return 0;
}

int ThreadRunner::wait()
{
for (int i = 0;i < _threadNumber ; i ++)
pthread_join(_threadId[i] , 0);

return 0;
}
Runner::Runner():_runner(0)
{}
Runner::~Runner()
{
if (_runner)
delete _runner;
_runner = 0;
}
int Runner::start(int threadNumber)
{
if (_runner == 0)
_runner = new ThreadRunner;

return _runner->start(threadNumber , this);
}

int Runner::stop()
{
if (_runner)
return _runner->stop();
else
return -1;
}
int Runner::wait()
{
if (_runner)
return _runner->wait();
else
return -1;
}
int Runner::run()
{
return 0;
}