文档章节

使用 acl 库编写多线程应用程序

郑树新
 郑树新
发布于 2014/08/26 08:56
字数 2014
阅读 780
收藏 2

      在 《利用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 

 


© 著作权归作者所有

共有 人打赏支持
郑树新

郑树新

粉丝 103
博文 87
码字总数 161171
作品 2
昌平
程序员
私信 提问
使用 acl 生成向导快速创建服务器程序

在以前有关使用 acl 的技术文章(如:使用 acl::masterthreads 类编写多进程多线程服务器程序 ,用 acl::masteraio 类编写高并发非阻塞服务器程序,使用 acl::master_proc 类编写多进程服务器...

郑树新
2014/09/03
0
0
acl_cpp 1.1.1.2 发布,C++网络框架库

经过了长时间的测试与项目实践,acl_cpp 1.1.1.2 版本终于发布了,acl_cpp 基于 C 语言版本的 acl 框架库而写的C++库,具备如下特性: 1)同步/异步网络通信框架;同步流既支持网络通信,又支...

郑树新
2012/08/19
1K
3
跨平台网络通信与服务器编程框架库(acl库)介绍

一、描述 acl 工程是一个跨平台(支持LINUX,WIN32,Solaris,MacOS,FreeBSD)的网络通信库及服务器编程框架,同时提供更多的实用功能 库。通过该库,用户可以非常容易地编写支持多种模式(...

郑树新
2014/08/23
0
0
使用 acl 库的 C 库编写多线程程序

一、概述   在当今强调多核开发的年代,要求程序员能够写出高并发的程序,而利用多个核一般有两种方式:采用多线程方式或多进程方式。每处理一个新任务时如果临时 产生一个线程或进程且处理...

郑树新
2014/08/26
0
0
协作半驻留式服务器程序开发框架 --- 基于 Postfix 服务器框架改造

一、概述  现在大家在和Java, PHP, .net写应用程序时,都会用到一些成熟的服务框架,所以开发效率是比较高的。而在用C/C++写服务器程序时,用的就五花八门了,有些人用ACE, 有些人用ICE(号...

郑树新
2014/08/31
0
2

没有更多内容

加载失败,请刷新页面

加载更多

nginx rails 详细站点配置入门教程

Ruby on Rails 是一个用于开发数据库驱动的网络应用程序的完整框架。Rails基于MVC(模型- 视图- 控制器)设计模式。从视图中的Ajax应用,到控制器中的访问请求和反馈,到封装数据库的模型,R...

xiangyunyan
44分钟前
3
0
Shiro

Shiro是Apache的一个开源框架,是一个权限管理的框架,实现用户认证、用户授权等。 只要有用户参与一般都要有权限管理,权限管理实现对用户访问系统的控制,按照安全规则或者安全策略控制用户...

嘿嘿嘿IT
48分钟前
1
0
Flutter 之 Dart语言基础详解 上篇

经过了一个星期的React Native的学习和了解,感觉还是Flutter的优势会更高一些,而且从学习成本来说感觉做安卓的同学学习flutter会相对低一点,门槛会低很多。 当然dart的基础笔者还是从其他...

林-师傅等等我
今天
5
0
Java NIO问题总结

问题1:IO事件在被处理之前,selector.select()方法依然能够返回该事件。即如果在一个线程A中进行selector.select(),而将selector.selectedKeys()中的SelectionKey交由业务线程池去处理,则...

月下狼
今天
5
0
ehcache

简单介绍 EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量...

大笨象会跳舞吧
今天
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部