ACE中的进程

ACE主要通过以下几种类来完成进程的创建、管理和控制。

ACE_Process 类  ：创建新进程

ACE_Process_Options类：   其对象负责携带新进程所需的各个选项，该对象也被称为选项对象。

ACE_Process_Manager类：  ACE的进程管理器 。该类允许用户通过一次调用来创建多个子进程， 并等待他们的结束、终止和退出。

关于ACE_Process的例子：

#include "ace/Log_Msg.h"
#include "ace/Process.h"
#include "ace/OS.h"

class Manager: public ACE_Process
{
 private:
  ACE_TCHAR strProgramName[64];

 public:
  Manager(const ACE_TCHAR* strProgramName)
  {
   ACE_DEBUG( (LM_DEBUG, ACE_TEXT("Manager::Manager()\n")) );
   ACE_OS::memset(this->strProgramName, 0, sizeof(this->strProgramName));
   ACE_OS::strcpy(this->strProgramName, strProgramName);
  }

  int doWork(void)
  {
   int nReturn = 0;
   ACE_DEBUG( (LM_DEBUG, ACE_TEXT("Manager::doWork()\n")) );

   //declare a ACE_Process_Options object options;
   ACE_Process_Options options;

   options.command_line(ACE_TEXT("calc"));

   //create an new process with options;
   pid_t pid = this->spawn(options);
   if(pid < 0)
   {
    ACE_DEBUG( (LM_ERROR, ACE_TEXT("failed to create sub process[%d]:%p\n"), pid, ACE_TEXT("spawn")) );
    return -1;
   }

   ACE_DEBUG( (LM_DEBUG, ACE_TEXT("spawn child: %d\n"), pid) );

   //wait for my child to exit
   nReturn = this->wait();
   if(nReturn < 0)
   {
    ACE_DEBUG( (LM_ERROR, ACE_TEXT("failed to wait[%d]\n"), nReturn, ACE_TEXT("wait")) );
    return -2;
   }
   return 0;
  }// end of the dowork()

  // 在创建新的子进程之前，ACE_Process::spawn()方法会自动调用进程对象的
  //ACE_Process::prepare()方法,以做一些预先的处理
  int prepare(ACE_Process_Options& options)
  {
   ACE_DEBUG( (LM_DEBUG, ACE_TEXT("ACE_Process::prepare\n")) );
   return 0;
  }

  //在CreatProcess函数（windows平台）被调用之后，该方法会立刻在父进程
  //中被回调
  void parent(pid_t child)
  {
   ACE_DEBUG( (LM_DEBUG, ACE_TEXT("parent(child): %d\n"), child) );
  }

  //在windows平台上，child函数不会被调用，因为在windows平台上
  //不存在fork（）和exec（）的概念
  void child(pid_t parent)
  {
   ACE_DEBUG( (LM_DEBUG, ACE_TEXT("child(parent): %d\n"), parent) );
  }
};


int ACE_TMAIN(int argc, ACE_TCHAR** argv)
{
 Manager m("GET_PROCESS");

 m.doWork();
 return 0;
}

1、ACE_Process类创建进程的步骤：

     1）创建一个新的ACE_Process_Options类的对象options， 为新的子进程指定进程属性

     2）用ACE_Process：：spawn（options）方法创建新的子进程。

2、举例说明如下：

    ACE_Process_Options options;

    ACE_Process process;

    options.command_line(ACE_TEXT("calc"));

    process.spawn(options);

    ACE_Process_Options::command_line()方法， 指定程序的命令和参数， 在“被创建进程”中启动新程序时会使用它们。

   一个选项对象可以用于多个ACE_Process对象， 栈上的ACE_Process对象，代表要创建的新进程， 该进程会基于传入

    的选项对象创建新的子进程。

    ACE_Process：：spawn（）方法：创建新的进程地址空间， 并运行指定的程序映像。

3、ACE_Process类的hook（挂钩）方法：

prepare（）：在创建新的子进程之前， ACE_Process：：spawn（）方法会自动调用进程对象的ACE_Process：：prepare（）

                                 方法， 来做一些预先的处理。返回0表示成功，会继续创建新进程，返回-1，表示失败，不再创建子进程。

parent（）：会在fork（）函数）（unix平台）或者CreatProcess（）函数（windows平台）被调用之后，立刻在父进程中被回调。

child（）：在fork（）函数之后，exec（）被调用之前，该方法会在子进程中被回调。但是该方法不会在windows平台下被调用，

因为在windows平台下没有fork（）和exec（）的概念。

4、ACE的进程管理器： ACE_Process_Manager

      需要使用该类的spawn（）方法来创建进程， 必须首先创建一个ACE_Process_Options对象， 指定要创建的子进程的

     各项属性，并将该类对象传递给spawn（）方法。

关于ACE_Process_Manager的例子

#include "ace/Log_Msg.h"
#include "ace/Process_Manager.h"
#include "ace/OS.h"

static const int NCHILDREN = 3;


//win32 控制台项目的入口函数
int ACE_TMAIN(int argc, ACE_TCHAR** argv)
{
 ACE_Process_Manager* pm = NULL;

 //ACE_Process_Manager::instance() 返回一个指向ACE_Process_Manager的单例模式的
 //的指针
 pm = ACE_Process_Manager::instance();

 //set sub process command
 ACE_Process_Options options;
 options.command_line(ACE_TEXT("ping 10.10.3.238 -c 5"));

 //create sub process
 pid_t pids[NCHILDREN];

 //同时创建三个子进程，且该进程组的属性都一样，options
 pm->spawn_n(NCHILDREN, options, pids);

 ACE_OS::sleep(1);

 //显式的终止一个子进程
 pm->terminate(pids[0]);

 //wait for all the processes exit;
 ACE_exitcode exitcode;
 for(int i = 0; i < NCHILDREN; i++)
 {
  ACE_DEBUG( (LM_DEBUG, ACE_TEXT("wait for sub [%d]process %d exit ......\n"), i, pids[i]) );
  pm->wait(pids[i], &exitcode); //等待进程组中的一些进程退出
  ACE_DEBUG( (LM_DEBUG, ACE_TEXT("[%d]process %d exit with code %d\n"), i, pids[i], exitcode) );
 }

 getchar();
 return 0;
}