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입니다. 이전에 정의할 수 있는 thandle은 라인 핸들입니다. 뒷부분의 인터페이스는 사용할 수 있습니다. 예를 들어 위의 예에서 사용한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 
"));
	}

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

이 인터페이스는 기본적으로 ACE 와 같은 N 스레드를 할당하는 데 사용됩니다.Thread::spawn, 여기 더 이상 설명 안 할게요.

int wait_grp (int grp_id);

스레드 그룹이 끝날 때까지 기다립니다, 여기grpid는 spawnn의 매개 변수
grp_id
ACE_Thread_Manager에서 제공하는 추가 인터페이스는 ace/thread 를 참조하십시오.manager.h의 선언
ACE_Task
간단한 예:

class CAceTask: public ACE_Task
{
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<

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는 이러한 모드를 구현하는 메커니즘을 제공합니다. ACETask 부팅 함수: open, open 허함수 내에서activate 함수를 통해 상응하는 수량의 스레드 탱크를 활성화할 수 있으며, 사용자 코드는 외부에서ACETask 대기열 삽입 요청ACE_Task 클래스의 큐는 ACE 입니다.Message_Queue 대기열, 다른 확장 버전 클래스 ACETask_Ex는 ACEMessage_Queue_Ex 대기열.Open 가상 함수 ACETask 클래스 내부에서 아무것도 하지 않았습니다. ACE의 습관인 오픈 함수로서 기본적으로 모든 클래스의 시작 함수입니다. 사용자 프로그램은 이 함수 내부에서 초기화 작업을 완성할 수 있습니다. 예를 들어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, thread ids), 마지막 매개 변수threadids는 다중 라인에서 유용합니다.
ACE_Task 스레드 실행 함수: svc svc 함수는 진정한 스레드 함수체이고 svc도 허함수입니다. 사용자가 리셋해야 합니다.activate를 통해 여러 스레드를 시작하면 svc 함수에서 ACEThread_::self()==thread_ids[i]를 비교하여 해당하는 사용자 처리 함수를 시작합니다.예를 들면 다음과 같습니다.

#define THREADS 2
class Task_Test : public ACE_Task
{
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
", code);
	return 0;
}
void Task_Test::handle_thread_1(u_long code)
{
	printf("this is thread:%d
", code);
}
void Task_Test::handle_thread_2(u_long code)
{
	printf("this is thread:%d
", code);
}
int main(int argv, char * argc[])
{
	Task_Test task;
	task.open(0);
	return 0;
}