Linux 和 Windows 下实现多进程的方式以及管道操作

一、多进程

1.windows 多进程

使用 #include<windows.h> 下面的

 BOOL  CreateProcess(
         LPCWSTR pszImageName,  LPCWSTR pszCmdLine,
         LPSECURITY_ATTRIBUTES psaProcess,
         LPSECURITY_ATTRIBUTES psaThread,
         BOOL fInheritHandles,  DWORD fdwCreate,
         LPVOID pvEnvironment,  LPWSTR pszCurDir,
         LPSTARTUPINFOW psiStartInfo,
         LPPROCESS_INFORMATION pProcInfo
 );

其中几个关键的形参为：

    参数pszImageName   //指向一个NULL终止的字符串，用来指定可执行程序的名字。

    e.g：

 STARTUPINFO sui;
 PROCESS_INFORMATION pi;
 ZeroMemory(&sui,sizeof(STARTUPINFO));
 sui.cb = sizeof(STARTUPINFO);
 sui.dwFlags = STARTF_USESTDHANDLES;
 sui.hStdInput = hRead;
 sui.hStdOutput = hWrite;
 sui.hStdError = GetStdHandle(STD_ERROR_HANDLE);
         CreateProcess("../.../run/Chilid.exe",NULL,NULL,NULL，TRUE，，NULL,NULL,&sui,&pi);

参数pszCmdLine    //用来指定传递给新进程的命令行字符串

    e.g：

  TCHAR szApp[MAX_PATH] = TEXT("netstat -s");
           CreateProcess(NULL,szApp,NULL,NULL，TRUE，，NULL,NULL,&sui,&pi);

     参数psiStartInfo   //指向一个 StartUpInfo 的结构体的指针，用来指定新进程的主窗口如何显示

 typedef struct _STARTUPINFOA {
     DWORD cb;
     LPSTR lpReserved;
     LPSTR lpDesktop;
     LPSTR lpTitle;
     DWORD dwX;
     DWORD dwY;
     DWORD dwXSize;
     DWORD dwYSize;
     DWORD dwXCountChars;
     DWORD dwYCountChars;
     DWORD dwFillAttribute;
     DWORD dwFlags;
     WORD wShowWindow;
     WORD cbReserved2;
     LPBYTE lpReserved2;
     HANDLE hStdInput;
     HANDLE hStdOutput;
     HANDLE hStdError;
 } STARTUPINFOA, *LPSTARTUPINFOA;

对于 dwFlags 参数来说，如果其设置为 STARTF_USESTDHANDLES ，则将会使用该 STARTUPINFO 结构体中的     hStdInput ， hStdOutput ， hStdError 成员，来设置新创       建的进程的标准输入，标准输出，标准错误句柄。

参数 pProcInfo    //为一个输出参数，指向一个 PROCESS_INFORMATION 结构体的指针，用来接收关于新进程的标识信息。

其中 hProcess 和 hThread 分别用来标识新创建的进程句柄和新创建的进程的主线程句柄。

      dwProcessId 和 dwThreadId 分别是全局进程标识符和全局线程标识符。前者可以用来标识一个进程，后者用来标识一个线程

 typedef struct _PROCESS_INFORMATION
 {   HANDLE hProcess;
     HANDLE hThread;
     DWORD dwProcessId;
     DWORD dwThreadId;
 }PROCESS_INFORMATION;

【注】CreateProcess()和CreateThread()的区别，是前者创建的是进程，而后者创建的是线程。

2. Linux下多进程

    Linux创建线程的主要方式有：

    <unistd.h> ---- fork();

<unistd.h> ---- exec系列;

<stdlib.h> ---- sysytem();

e.g

system("cd /home/root/");

【注】linux下创建线程的方式

<pthread.h> ---- pthread_create

e.g：

int * thread(void *arg){}

pthread_t id;   //记录创建线程的id

pthread_create(&id,NULL,(void*) thread,NULL);

二、管道

1、windows 下的管道

a. 匿名管道 -- 进程和其子进程之间通信

 #include<iostream>
 #include <windows.h>
 #define MAX_PATH 1024
 using namespace std;
 int main(){
 TCHAR szApp[MAX_PATH] = TEXT("netstat -s");
  char ReadBuf[];
  DWORD ReadNum;
  HANDLE hRead = NULL; // 管道读句柄
  HANDLE hWrite = NULL; // 管道写句柄
     SECURITY_ATTRIBUTES sa = {};
     sa.nLength = sizeof(sa);
     sa.lpSecurityDescriptor = NULL;
     sa.bInheritHandle = TRUE;
     bool bRet = CreatePipe(&hRead, &hWrite, &sa, );
     if (bRet)
     {
      cout<<"创建管道成功"<<endl;
     }
     else{
      cout<<"创建管道失败"<<endl;
     }
     STARTUPINFO si = {sizeof(si)};
     PROCESS_INFORMATION pi = {};
     si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
     si.hStdOutput = hWrite;
     si.hStdError = hWrite;
     si.wShowWindow = SW_HIDE;
     HANDLE hTemp = GetStdHandle(STD_OUTPUT_HANDLE);
     GetStartupInfo(&si);
     bRet = CreateProcess(NULL,szApp,NULL,NULL,TRUE,NULL,NULL,NULL,&si,&pi);  //创建一个执行命令行的进程
     CloseHandle(pi.hThread);
     CloseHandle(pi.hProcess);
     CloseHandle(hWrite);
     int i = ;
     while(ReadFile(hRead,ReadBuf,,&ReadNum,NULL)){       //对管道进行读操作
      ReadBuf[ReadNum] = '\0';
         cout<<"panfei"<<endl;
         cout<<i++<<endl;
      //cout<<ReadBuf<<endl;
     }
     if(GetLastError() == ERROR_BROKEN_PIPE)
      cout<<"管道被子进程关闭"<<endl;
     ExitProcess();
  return ;
 }

b. 命名管道 -- 可以实现两个无任何亲缘关系的进程之间的数据传递

server端：

 #include <iostream>
         #inserclude <Windows.h>
         HANDLE hpipe = INVALID_HANDLE_VALUE;
         LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");    //★管道的名称必须这样命名，托付给系统管理
         int main(){
  SECURITY_ATTRIBUTES sa;
  sa.bInheritHandle = TRUE;
  sa.lpSecurityDescriptor = NULL;
  sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  hpipe = CreateNamedPipe(                                                //创建命名pipe
   lpszPipename,             // pipe name
   PIPE_ACCESS_DUPLEX,       // read/write access
   PIPE_TYPE_MESSAGE |       // message type pipe
   PIPE_READMODE_MESSAGE |   // message-read mode
   PIPE_WAIT,                // blocking mode
   PIPE_UNLIMITED_INSTANCES, // max. instances
   BUFSIZ,                   // output buffer size
   BUFSIZ,                   // input buffer size
   ,                        // client time-out
   NULL);                    // default security attribute
  if (hpipe == INVALID_HANDLE_VALUE)
  {
   cout<<"CreateNamedPipe failed, GLE=%d.\n"<<endl;;
   return -;
  }
  BOOL fConnected = ConnectNamedPipe(hpipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);   //等待有其他进程连接该pipe ,一旦有进程连接该pipe,下面的代码才会执行
  char buf[] = {'a','b','a','\0'};
  WriteFile(hpipe,buf,,NULL,NULL);
  return ;
 }

client端：

  int main(){
              hPipe = CreateFile(             //连接server创建的pipe
                       lpszPipename,   // pipe name
                       GENERIC_READ |  // read and write access
                       GENERIC_WRITE,
                       ,              // no sharing
                       NULL,           // default security attributes
                       OPEN_EXISTING,  // opens existing pipe
                       ,              // default attributes
                       NULL);          // no template file
               DWORD dwMode = PIPE_READMODE_MESSAGE;
               BOOL fSuccess = SetNamedPipeHandleState(            //设置管道的状态，设置到读取状态
               hPipe,    // pipe handle
               &dwMode,  // new pipe mode
               NULL,     // don't set maximum bytes
                                     NULL);    // don't set maximum time
               DWORD cbRead;
               fSuccess = ReadFile(                                        //读取管道中的数据
               hPipe,    // pipe handle
               readBuf,    // buffer to receive reply
               BUFSIZ*sizeof(TCHAR),  // size of buffer
               &cbRead,  // number of bytes read
                NULL);    // not overlapped
               cout<<readBuf<<endl;
         }

2.  Linux 下的管道

a. 匿名管道

e.g

  #include<stdio.h>
            #include<stdlib.h>
            #include<unistd.h>
            int main(){
                 int pfd[];                  //用于保存打开管道后的两个文件描述符号
                 pid_t cpid;                 //进程id
                 char buf;
                 if(pipe(pfd) == -){
                       fprintf("Pipe created fail!");
                 }
                 cpid = fork();
                 if(cpid == ){
                        close(pfd[]);       //读管道前关闭管道写端
                        while(read(pfd[],&buf,){     //读取管道
                             printf("%s\n",buf);
                         }
                         exit()                //退出子进程
                 }
                 else{
                       char writeBuf[] = {'a','b','c'};
                       close(pfd[]);
                       wirte(pfd[],writeBuf,sizeof(writeBuf));     //向管道中写入数据
                       exit();
                 }
            }

b. 命名管道

参考：http://www.cppblog.com/wanghaiguang/archive/2012/11/20/195412.html