利用ACE管理线程

   我所接触的ACE中对线程操作的类主要有两个，一个是ACE_Thread，另一个为ACE_Thread_Manager

  ACE_Thread能够管理所有线程，只要你掌握有需要被管理的线程的ID；ACE_Thread_Manager的一个对象能够管理该对象所创建的线程。

  一个线程可以通过传入THR_JOINABLE属性来创建，从而可以在其他线程(并不一定要是创建该线程的线程或者主线程)等待该线程结束、捕获该线程函数的返回值、回收该线程资源；也可以通过传入THR_DETACHED属性来使得被创建的线程自动在线程函数结束后释放资源，这种线程无法在其他线程中等待它的结束。

  创建一个线程的函数有：

                   /*通过ACE_Thread类中的函数创建一个线程

                    *CreateFunc为自己定义的一个全局函数原型为void CreateFunc(TestTask* p)

                    *&test为线程函数需要传入的参数TestTask* p

                    *THR_NEW_LWP | THR_DETACHED指定线程的属性，该线程属于能够自动释放资源的那种，至于THR_NEW_LWP的含义，我想大概是指创建一个轻量级线程的意思，可以参考一下http://www.linuxsir.org/bbs/printthread.php?t=55674

                    *最后用一个变量nThreadId来接受被创建的线程的线程ID

                    */

                  ACE_Thread::spawn((ACE_THR_FUNC)CreateFunc,&test, THR_NEW_LWP | THR_DETACHED,&nThreadId);

 

                  /*通过ACE_Thread_Manager的对象创建线程，pThreadManager为ACE_Thread_Manager的一个指针

                   *spawn函数的形参的意义都一样

                   *THR_JOINABLE 表示被创建的线程需要通过其他线程调用join方法来释放资源，并可以通过pThreadManager->join(nthreadId)来等待线程结束

                   *THR_SUSPENDED代表线程可以被挂起，但是并不是创建时传入了该属性的线程就能挂起，我的那个线程函数MyThread::func就没法被挂起，还望高手指点

                   */

                    pThreadManager->spawn((ACE_THR_FUNC)MyThread::func,NULL, THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED|THR_SUSPENDED,&m_nThreadId)

 

    代码:

#include "ace/Thread.h"
#include "ace/Thread_Manager.h"
#include "ace/Task.h"
#include "ace/Reactor.h"

#include <iostream>

using namespace std;

class MyThread
{
public:
 static int func()
 {
  int count = 1000;
  for(int i=0;i<count;i++)
  {
   cout<<"Enter Thread Func"<<i<<endl;
   if (  i%50 == 1 )
    ACE_OS::sleep(1);
  }
  return 0; 
 }
};

class TestTask : public ACE_Task<ACE_MT_SYNCH>
{
public:
 TestTask():ACE_Task<ACE_MT_SYNCH>(new ACE_Thread_Manager)
 {
  reactor(new ACE_Reactor);
  m_nThreadId= 0;
  activate(); 
 }
 
 long Create()
 {
  cout<<"Spawn Thread Return:"<<thr_mgr()->spawn((ACE_THR_FUNC)MyThread::func,NULL, THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED|THR_SUSPENDED,&m_nThreadId)<<endl;
  cout<<"Create Thread Id="<<m_nThreadId<<endl;
  return m_nThreadId; 
 }
 
 int Suspend()
 {
  return thr_mgr()->suspend(m_nThreadId); 
 }
 
 int Resume()
 {
  return thr_mgr()->resume(m_nThreadId); 
 }
 
 void Stop()
 {
  cout<<"Join Thread Return:"<<thr_mgr()->join(m_nThreadId)<<endl; 
 }
 
 int svc()
 {
  reactor()->owner(ACE_Thread::self());
  reactor()->run_reactor_event_loop();
  return 0; 
 }
 
 ACE_thread_t m_nThreadId;
};

void CreateFunc(TestTask* p)
{
 //while(1)
 {
  p->Create();
  //ACE_OS::sleep(5);
 } 
}

void JoinFunc(TestTask* p)
{
 p->Stop(); 
}

int main()
{
 TestTask test;
 
 ACE_thread_t nThreadId = 0;
 ACE_Thread::spawn((ACE_THR_FUNC)CreateFunc,&test, THR_NEW_LWP | THR_DETACHED,&nThreadId);
  
 ACE_OS::sleep(1);
 cout<<test.Suspend()<<endl;
 cout<<"OK"<<endl;
 int a;
 cin>>a;
 cout<<test.Resume()<<endl;
 cout<<"main join:"<<ACE_Thread::join(nThreadId)<<endl;
 ACE_OS::sleep(3);
 ACE_Thread::spawn((ACE_THR_FUNC)JoinFunc,&test, THR_NEW_LWP | THR_JOINABLE,&nThreadId);
 
 
 cout<<ACE_Thread::join(nThreadId)<<endl;
 
 while(1)
  ACE_OS::sleep(1);
 return 0; 
}