ACE:多线程简介

由于也刚初学，这里打算从自己的一些理解，简单介绍下ACE_Thread、ACE_Thread_Manager、ACE_Task

这里先简单些一点，有时间再做补充

ACE_Thread

一个简单例子

入口函数：

void* worker(const char* arg)
{
	ACE_OS::sleep(10);
	puts(arg);
	return NULL;
}

创建线程和等待结束：

ACE_thread_t ThreadID;
ACE_hthread_t Handle;

ACE_Thread::spawn(ACE_THR_FUNC(worker),"Hello,World!",THR_JOINABLE | THR_NEW_LWP,&ThreadID,&Handle);

ACE_Thread::join(Handle);

执行结果：

简要说明：

static int spawn (ACE_THR_FUNC func,
                    void *arg = 0,
                    long flags = THR_NEW_LWP | THR_JOINABLE,
                    ACE_thread_t *t_id = 0,
                    ACE_hthread_t *t_handle = 0,
                    long priority = ACE_DEFAULT_THREAD_PRIORITY,
                    void *stack = 0,
                    size_t stack_size = ACE_DEFAULT_THREAD_STACKSIZE,
                    ACE_Thread_Adapter *thread_adapter = 0,
                    const char** thr_name = 0);

此接口用于创建线程，其中参数func为创建的线程执行的函数，arg为函数的实参，flags一般采用默认，t_id为线程ID，之前可以定义一个，t_handle为线程句柄，后边一些接口可以使用到，比如上面例子使用的join

 static int join (ACE_hthread_t,
                   ACE_THR_FUNC_RETURN * = 0);

此接口用于等待线程结束，第一个参数为spawn创建的线程句柄

其他几个接口介绍：

static void exit (ACE_THR_FUNC_RETURN status = 0);

终止线程

 static int setprio (ACE_hthread_t ht_id, int priority, int policy = -1);

设置线程优先级

static int suspend (ACE_hthread_t);

挂起线程

static int resume (ACE_hthread_t);

恢复线程

还有其他一些接口，具体可以参考ace\thread.h中的接口声明

ACE_Thread_Manager

if(-1 == ACE_Thread_Manager::instance()->spawn_n(2,ACE_THR_FUNC(worker),"Hello,World!",THR_NEW_LWP,ACE_DEFAULT_THREAD_PRIORITY,1))
	{
		ACE_ERROR((LM_ERROR, "Failure to spawn first group of threads: %p \n"));
	}

	ACE_Thread_Manager::instance()->wait_grp(1);

执行结果：

简要说明：

int spawn_n (size_t n,
               ACE_THR_FUNC func,
               void *arg = 0,
               long flags = THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED,
               long priority = ACE_DEFAULT_THREAD_PRIORITY,
               int grp_id = -1,
               ACE_Task_Base *task = 0,
               ACE_hthread_t thread_handles[] = 0,
               void *stack[] = 0,
               size_t stack_size[] = 0,
               const char* thr_name[] = 0);

此接口用于分配N个线程，参数含义基本同ACE_Thread::spawn,这里不再另外说明

int wait_grp (int grp_id);

等待线程组结束，这里的grp_id为spawn_n的参数 grp_id

ACE_Thread_Manager提供的其他接口可以参考ace/thread_manager.h中的声明

ACE_Task

简单例子：

class CAceTask: public ACE_Task<ACE_MT_SYNCH>
{
public:
	int open();
	int svc();
	int close();
};

int CAceTask::open()
{
	//激活3个线程
	return activate(THR_NEW_LWP,3);
}

int CAceTask::svc()
{
	ACE_Message_Block *MsgDate = NULL;
	const char *sp = NULL;
	do
	{
		//超时时间设置
		timeval tm;
		tm.tv_sec = 1;
		ACE_Time_Value timeValue(tm);
		
		
		//获取put的数据，这里只等待1秒
		if(-1 == getq(MsgDate,&timeValue))
		{
			break;
		}

		sp = (const char*)MsgDate->rd_ptr();
		MsgDate->release();		 //释放Message_Block

		cout<<sp<<endl;

		//释放指针
		delete sp;
		sp = NULL;
	}
	while(true);

	return 0;
}

CAceTask t;
	t.open();

	ACE_Message_Block *MsgDate = NULL;

	for(int i = 0; i != 5; ++i)
	{
		char *sp = new char[6];
		strcpy(sp,"wwwww");
	

		MsgDate = new ACE_Message_Block(sp,6);
		t.putq(MsgDate);
	}
    
	//等待线程全部结束
	ACE_Thread_Manager::instance()->wait();

简单介绍：

ACE_Task提供了实现这种模式的机制，ACE_Task启动函数：open，在open虚函数内可以通过activate函数激活相应数量的线程池，用户代码可以在外部向ACE_Task队列插入请求。
ACE_Task类中的队列采用ACE_Message_Queue队列，另外一个扩展版本类ACE_Task_Ex采用了ACE_Message_Queue_Ex队列。
Open虚函数在ACE_Task类内部并没有做任何事情，作为ACE的习惯open函数基本上时所有类的起始函数，用户程序可以在此函数内部完成初始化工作，比如调用activate启动线程

Activate函数定义如下：

activate(long flags = THR_NEW_LWP | THR_JOINABLE |THR_INHERIT_SCHED ,

                        int n_threads = 1,

                        int force_active = 0,

                        long priority =ACE_DEFAULT_THREAD_PRIORITY,

                        int grp_id = -1,

                        ACE_Task_Base *task =0,

                        ACE_hthread_tthread_handles[] = 0,

                        void *stack[] = 0,

                        size_t stack_size[] =0,

                        ACE_thread_tthread_ids[] = 0);

这个函数参数看上去比较多，其实大部分都可以使用缺省参数，用户在调用时可以只调用activate()或者activate(LWP_NEW_THR, 1)。如果需要启动多个线程时我们可以这样调用activate(LWP_NEW_THR, 10, 0,ACE_DEFAULT_THREAD_PRIORITY, -1, 0, 0, 0, 0, thread_ids)，最后一个参数thread_ids在多线程中时有用的。

ACE_Task线程运行函数：svc

svc函数是真正的线程函数体，svc也是虚函数需要用户重置，当通过activate启动多个线程后，我们可以在svc函数体内根据ACE_Thread_::self()==thread_ids[i] 比较来启动相应的用户处理函数。例如：

#define THREADS 2
class Task_Test : public ACE_Task<ACE_MT_SYNCH>
{
public:
	~Task_Test();
	int open(void*);
	int svc(void);
	int close(u_long);
private:
	void handle_thread_1(u_long);
	void handle_thread_2(u_long);
private:
	ACE_thread_t thread_ids[THREADS];
};
Task_Test::~Task_Test()
{
	wait();       //等待所有的线程退出
}
int Task_Test::open(void*)
{
	activate(THR_NEW_LWP,
		THREADS,
		0,
		ACE_DEFAULT_THREAD_PRIORITY,
		-1,
		0,
		0,
		0,
		0,
		thread_ids);
	return 0;
}
int Task_Test::svc(void)
{
	for (int i = 0; i < THREADS; i++) {
		if (ACE_Thread::self() == thread_ids[i])
			switch (i) {
			case 0:
				handle_thread_1(thread_ids[i]);
				break;
			case 1:
				handle_thread_2(thread_ids[i]);
				break;
			default:
				break;
			}
	}
	return 0;
}
int Task_Test::close(u_long code)
{
	printf("thread exit:%d\n", code);
	return 0;
}
void Task_Test::handle_thread_1(u_long code)
{
	printf("this is thread:%d\n", code);
}
void Task_Test::handle_thread_2(u_long code)
{
	printf("this is thread:%d\n", code);
}
int main(int argv, char * argc[])
{
	Task_Test task;
	task.open(0);
	return 0;
}