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;
}