首页 > 代码库 > 使用 acl 库编写多线程应用程序
使用 acl 库编写多线程应用程序
在 《利用ACL库开发高并发半驻留式线程池程序》 中介绍了如何使用 C 版本的 acl 线程库编写多线程程序，本文将会介绍如何使用 C++ 版本的 acl 线程库编写多线程程序，虽然 C++ 版 acl 线程库基于 C 版的线程库，但却提供了更为清晰简洁的接口定义（很多地方参考了 JAVA 的线程接口定义）。下面是一个简单的使用线程的例子：
#include "acl_cpp/lib_acl.hpp"
//////////////////////////////////////////////////////////////////////////
// 子线程类定义
class mythread : public acl::thread
{
public:
mythread() {}
~mythread() {}
protected:
// 基类纯虚函数，当在主线程中调用线程实例的 start 函数时
// 该虚函数将会被调用
virtual void* run()
{
const char* myname = "run";
printf("%s: thread id: %lu, %lu\r\n",
myname, thread_id(), acl::thread::thread_self());
return NULL;
}
};
//////////////////////////////////////////////////////////////////////////
static void test_thread(void)
{
const char* myname = "test_thread";
mythread thr; // 子线程对象实例
// 设置线程的属性为非分离方式，以便于下面可以调用 wait
// 等待线程结束
thr.set_detachable(false);
// 启动一个子线程
if (thr.start() == false)
{
printf("start thread failed\r\n");
return;
}
printf("%s: thread id is %lu, main thread id: %lu\r\n",
myname, thr.thread_id(), acl::thread::thread_self());
// 等待子线程运行结束
if (thr.wait(NULL) == false)
printf("wait thread failed\r\n");
else
printf("wait thread ok\r\n");
}
int main(void)
{
// 初始化 acl 库
acl::acl_cpp_init();
test_thread();
#ifdef WIN32
printf("enter any key to exit ...\r\n");
getchar();
#endif
return 0;
}
从上面的示例来看，使用 acl 的线程库创建使用线程还是非常简单的。打开 lib_acl_cpp/include/acl_cpp/stdlib/thread.hpp 文件，可以看到线程类的声明，其中有两个基类：acl::thread 与 acl::thread_job，在 基类 acl::thread_job 中有一个纯虚函数 run（），acl::thread 也继承自 acl::thread_job，用户的线程类需要继承 acl::thread，并且需要实现基类 acl::thread_job 的纯虚函数： run（）。当应用在主线程中调用线程实例的 start() 函数时，acl 线程库内部便创建一个子线程，子线程被创建后线程对象的 run() 函数便被调用。下面是 acl::thread 类中几个主要的方法定义：
class thread_job
{
public:
thread_job() {}
virtual ~thread_job() {}
/**
* 纯虚函数，子类必须实现此函数，该函数在子线程中执行
* @return {void*} 线程退出前返回的参数
*/
virtual void* run() = 0;
};
class thread : public thread_job
{
public:
thread();
virtual ~thread();
/**
* 开始启动线程过程，一旦该函数被调用，则会立即启动一个新的
* 子线程，在子线程中执行基类 thread_job::run 过程
* @return {bool} 是否成功创建线程
*/
bool start();
/**
* 当创建线程时为非 detachable 状态，则可以调用此函数
* 等待线程结束；否则，若创建线程时为 detachable 状态
* 在调用本函数时将会报错
* @param out {void**} 当该参数非空指针时，该参数用来存放
* 线程退出前返回的参数
* @return {bool} 是否成功
*/
bool wait(void** out = NULL);
/**
* 在调用 start 前调用此函数可以设置所创建线程是否为
* 分离 (detachable) 状态；如果未调用此函数，则所创建
* 的线程默认为分离状态
* @param yes {bool} 是否为分离状态
* @return {thread&}
*/
thread& set_detachable(bool yes);
/**
* 在调用 start 前调用此函数可以设置所创建线程的堆栈大小
* @param size {size_t} 线程堆栈大小，当该值为 0 或未
* 调用此函数，则所创建的线程堆栈大小为系统的默认值
* @return {thread&}
*/
thread& set_stacksize(size_t size);
/**
* 在调用 start 后调用此函数可以获得所创建线程的 id 号
* @return {unsigned long}
*/
unsigned long thread_id() const;
/**
* 当前调用者所在线程的线程 id 号
* @return {unsigned long}
*/
static unsigned long thread_self();
....
};
从上面的线程示例及 acl::thread 的类定义，也许有人会觉得应该把 acl::thread_job 的纯虚方法：run() 放在 acl::thread 类中，甚至觉得 acl::thread_job 类是多余的，但是因为 acl 库中还支持线程池方式，则 acl::thread_job 就显得很有必要了。在 lib_acl_cpp\include\acl_cpp\stdlib\thread_pool.hpp 头文件中可以看到 acl 的线程池类 acl::thread_pool 的声明，该类的主要函数接口如下：
class thread_pool
{
/**
* 启动线程池，在创建线程池对象后，必须首先调用此函数以启动线程池
*/
void start();
/**
* 停止并销毁线程池，并释放线程池资源，调用此函数可以使所有子线程退出，
* 但并不释放本实例，如果该类实例是动态分配的则用户应该自释放类实例，
* 在调用本函数后，如果想重启线程池过程，则必须重新调用 start 过程
*/
void stop();
/**
* 等待线程池中的所有线程池执行完所有任务
*/
void wait();
/**
* 将一个任务交给线程池中的一个线程去执行，线程池中的
* 线程会执行该任务中的 run 函数
* @param job {thread_job*} 线程任务
* @return {bool} 是否成功
*/
bool run(thread_job* job);
/**
* 将一个任务交给线程池中的一个线程去执行，线程池中的
* 线程会执行该任务中的 run 函数；该函数功能与 run 功能完全相同，只是为了
* 使 JAVA 程序员看起来更为熟悉才提供了此接口
* @param job {thread_job*} 线程任务
* @return {bool} 是否成功
*/
bool execute(thread_job* job);
/**
* 在调用 start 前调用此函数可以设置所创建线程的堆栈大小
* @param size {size_t} 线程堆栈大小，当该值为 0 或未
* 调用此函数，则所创建的线程堆栈大小为系统的默认值
* @return {thread&}
*/
thread_pool& set_stacksize(size_t size);
/**
* 设置线程池最大线程个数限制
* @param max {size_t} 最大线程数，如果不调用此函数，则内部缺省值为 100
* @return {thread_pool&}
*/
thread_pool& set_limit(size_t max);
/**
* 设置线程池中空闲线程的超时退出时间
* @param ttl {int} 空闲超时时间(秒)，如果不调用此函数，则内部缺省为 0
* @return {thread_pool&}
*/
thread_pool& set_idle(int ttl);
......
};
这些接口定义也相对简单，下面给出一个使用线程池的例子：
// 线程工作类
class myjob : public acl::thread_job
{
public:
myjob() {}
myjob() {}
protected:
// 基类中的纯虚函数
virtual void* run()
{
const char* myname = "run";
printf("%s: thread id: %lu\r\n",
myname, acl::thread::thread_self());
return NULL;
}
};
//////////////////////////////////////////////////////////////////////////
// 线程池类
class mythread_pool : public acl::thread_pool
{
public:
mythread_pool() {}
~mythread_pool()
{
printf("thread pool destroy now, tid: %lu\r\n",
acl::thread::thread_self());
}
protected:
// 基类虚函数，当子线程被创建时该虚函数将被调用
virtual bool thread_on_init()
{
const char* myname = "thread_on_init";
printf("%s: curr tid: %lu\r\n", myname,
acl::thread::thread_self());
return true;
}
// 基类虚函数，当子线程退出前该虚函数将被调用
virtual void thread_on_exit()
{
const char* myname = "thread_on_exit";
printf("%s: curr tid: %lu\r\n", myname,
acl::thread::thread_self());
}
};
//////////////////////////////////////////////////////////////////////////
void test()
{
acl::thread_pool* threads = new mythread_pool();
threads->start(); // 启动线程池过程
acl::thread_job *job1= new mythread, *job2 = new mythread;
threads->execute(job1);
threads->execute(job2);
// 为了保证 job1, job2动态内存被正确释放，
// 必须调用 threads->stop 等待子线程运行结束后在
// 主线程中将其释放
threads->stop();
delete threads;
// 在主线程中释放动态分配的对象
delete job1;
delete job2;
}
如上例所示，在使用 acl 的C++版本线程池类库时，必须定义一个线程工作类（继承自 acl::thread_job）并实现基类的纯虚函数：run()；另外，在使用线程池时，如果想要在线程创建时初始化一些线程局部变量以及在线程退出 前释放一些线程局部变量，则可以定义 acl::thread_pool 的子类，实现基类中的 thread_on_init 和 thread_on_exit 方法，如果不需要，则可以直接使用 acl::thread_pool 类对象。
下载：http://sourceforge.net/projects/acl/
svn：svn checkout svn://svn.code.sf.net/p/acl/code/trunk acl-code
github：https://github.com/zhengshuxin/acl
QQ 群：242722074
使用 acl 库编写多线程应用程序