阿修罗的线程类（以boost::thread为基础，增加了终止线程的功能）

[anrxhzh]

//阿修罗的线程类（以boost::thread为基础，增加了终止线程的功能）
//欢迎指正

//module.h
#ifndef ASHURA_MODULE_HEADER
#define ASHURA_MODULE_HEADER

#include <boost/utility.hpp>

namespace ashura {

class controlled_module_implement;
class controlled_module : boost::noncopyable {
public:
virtual void run();
bool exit(unsigned long sec=0);
protected:
controlled_module();
virtual ~controlled_module();
private:
virtual bool initialize()=0;
virtual void release()=0;
virtual bool work()=0;
private:
controlled_module_implement* impl_;
};

}

#endif

//module.cpp
#pragma warning (disable:4786)
#include "module.h"
#include "janitor.h"
#include <boost/thread/xtime.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>

namespace ashura {

class controlled_module_implement : boost::noncopyable {
public:
controlled_module_implement() :active_(false),command_exit_(false){}
boost::condition module_is_exit;
boost::mutex monitor;
void active(bool ac)
{boost::mutex::scoped_lock lk(monitor); if(!(active_=ac))module_is_exit.notify_all();else command_exit_=false;}
bool command_exit(){boost::mutex::scoped_lock lk(monitor); return command_exit_;}
bool active_,command_exit_;

};

controlled_module::controlled_module()
:impl_(new controlled_module_implement)
{
}

controlled_module::~controlled_module()
{
delete impl_;
}

void controlled_module::run()
{
ObjJanitor janitor(*impl_,&controlled_module_implement::active,false);
impl_->active(true);
{
ObjJanitor janitor(*this,&controlled_module::release);
if(this->initialize())
{
while(!impl_->command_exit() && this->work());
}
}
}

bool controlled_module::exit(unsigned long sec)
{
boost::mutex::scoped_lock lk(impl_->monitor);
impl_->command_exit_ = true;
while(impl_->active_)
{
if(sec)
{
boost::xtime xt;
boost::xtime_get(&xt, boost::TIME_UTC);
xt.sec += sec;
if(!impl_->module_is_exit.timed_wait(lk,xt))
return false;
}
else
impl_->module_is_exit.wait(lk);
}
return true;
}

}

//main.cpp
#include "module.h"
#include <boost/thread/thread.hpp>
#include <iostream>
#include <boost/thread/xtime.hpp>
#include <windows.h>

struct test : public ashura::controlled_module {
test():i(0){};
bool initialize(){std::cout<<"initialize\n";return true;}
bool work(){std::cout<<i<<std::endl;Sleep(1000);return i++<6;}
void release(){std::cout<<"release\n";};
private:
int i;
};

static test module;

void func()
{
module.run();
}

int main()
{
for(int i=0;i<3;i++)
{
boost::thread t(&func);
Sleep(10);
std::cout << "exit module " << module.exit() << std::endl;
t.join();
std::cout << std::endl;
}
return 0;
}

//测试结果
initialize
0
release
exit module 1

initialize
1
release
exit module 1

initialize
2
release
exit module 1

[anrxhzh]

增加了运行模块的单实例限制。

class controlled_module_implement : boost::noncopyable {
public:
boost::mutex monitor,instance;
...
};

void controlled_module::run()
{
boost::mutex::scoped_lock lk(impl_->instance);
...
}

[anrxhzh]

哪位好心人顶一下，让俺把这个帖子结了。多谢了。

[wkoji]

UP

[nikitar]

d

[denghby]

hehe ~~~~~~~~~~~

up