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_Blockcout<<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 2class 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;}