Linux开发简单多进程应用

一个进程中的多个线程共享一个进程的堆等内存空间，所以实现数据交互是很方便的；但多进程架构中，要想实现多进程间的数据交互相对就困难很多！

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传递或交换信息。IPC常见的方式有：管道（无名管道、命名管道）、消息队列、信号量、共享内存、磁盘文件、Socket等，其中Socket网络方式可以实现不同主机上的多进程IPC

一个带坑的小例子

下面使用fork()、pipe()实现一个简单的Linux平台下的多进程、多进程通信的程序

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main()
{
  int pipefd[2];    //两个文件描述符
  pid_t pid;
  char buff[20];
  int i;

  //创建管道
  if(0 > pipe(pipefd)){
    printf("Create Pipe Error!\n");
  }

  //创建2个子进程
  for(i=0; i<2; i++){
    pid = fork();

    if((pid_t)0 >= pid){
      sleep(1);
      break;
    }
  }
  //如果fork返回值小于0，说明创建子进程失败
  if((pid_t)0 > pid){
    printf("Fork Error!\n");
    return 3;
  }
  
  //如果fork返回值为0，表示进入子进程的逻辑
  if((pid_t)0 == pid){
    //发送格式化数据给主进程
    FILE *f;
    f = fdopen(pipefd[1], "w");
    fprintf(f, "I am %d\n", getpid());
    fclose(f);

    sleep(1);

    //接收父进程发过来的数据
    read(pipefd[0], buff, 20);
    printf("MyPid:%d, Message:%s", getpid(), buff);
  }
  //进入父进程的逻辑
  else{
    //循环接收所有子进程发过来的数据，并且返回数据给子进程
    for(i=0; i<2; i++){
      //接收子进程发来的数据
      read(pipefd[0], buff, 20);
      printf("MyPid:%d, Message:%s", getpid(), buff);

      //发送数据给子进程
      write(pipefd[1], "Hello My Son\n", 14);
    }
    //这里调用sleep(3)主要的作用是等待子进程运行结束
    //当然这样并不是很规范！
    sleep(3);
  }

  return 0;
}

编译程序gcc process.c -o process，然后执行./process输入信息如下

但我们可以发现输出的内容有一些异常，比如第二行最开始怎么有一个@字符、最后一行明显丢失了一些字符信息等

上面的程序还不止是输出不符合预期这个表面的问题，还存在诸多的坑，都是因为一开始对于多进程、管道的深入机制理解不正确造成的！

下面针对Linux的管道进行比较深入的挖掘，就可以发现上面的小程序中存在很多的坑

管道是阻塞的

管道读写是阻塞的，当管道中没有数据，但进程尝试去读的时候就会阻塞进程，比如

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main()
{
  int pipefd[2];
  pid_t pid;
  char buff[20];
  int i;

  if(0 > pipe(pipefd)){
    printf("Create Pipe Error!\n");
  }

  pid = fork();

  if((pid_t)0 > pid){
    printf("Fork Error!\n");
    return 3;
  }
  
  if((pid_t)0 == pid){
    //write(pipefd[1], "Hello\n", 6);
  }
  else{
    read(pipefd[0], buff, 20);
    printf("MyPid:%d, Message:%s", getpid(), buff);
  }

  return 0;
}

其运行效果如下，可以看到主进程阻塞住了

可以修改让子进程往管道中写入数据，主进程再去读，这样就不会阻塞了

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main()
{
  int pipefd[2];
  pid_t pid;
  char buff[20];
  int i;

  if(0 > pipe(pipefd)){
    printf("Create Pipe Error!\n");
  }

  pid = fork();

  if((pid_t)0 > pid){
    printf("Fork Error!\n");
    return 3;
  }
  
  if((pid_t)0 == pid){
    
  }
  else{
    read(pipefd[0], buff, 20);
    printf("MyPid:%d, Message:%s", getpid(), buff);
  }

  return 0;
}

运行程序可以看到主进程没有阻塞

管道是半双工的

所谓半双工，意思就是只能在一个方向上传递数据，对于pipe，只能从pipe[1]写，从pipe[0]读，只能在一个方向传递数据；可以结合socket来理解，socket是全双工的，也就是针对一个socket既可以写又可以读

第一个例程中创建了一个管道，但却希望通过这个管道实现主进程传递数据给子进程、子进程传递数据给主进程，完全是想在两个方向传递数据，结果导致主进程和2个子进程同时既往管道里写，又从管道里读，所以出现了上述诡异的现象

比如下面这个例子，创建一个管道，但不创建子进程，可以在主进程既写又读管道！

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main()
{
  int pipefd[2];
  pid_t pid;
  char buff[20];
  int i;

  if(0 > pipe(pipefd)){
    printf("Create Pipe Error!\n");
  }

  write(pipefd[1], "Hello\n", 6);
  read(pipefd[0], buff, 20); 
  printf("MyPid:%d, Message:%s", getpid(), buff);

  return 0;
}

因为管道是半双工的，所以要想在保证数据不乱的情况下，不能在多进程应用中只使用一个管道，需要一套管道，有的是数据从主进程到子进程，有的是数据从子进程到主进程

完善后的程序

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main()
{
  //管道1,用于子进程发送数据给主进程
  int pipefd[2];
  //管道数组2,用于主进程分别发数据给子进程
  int pipearr[3][5];

  pid_t pid;
  char buff[20];
  int i;

  //创建管道
  if(0 > pipe(pipefd)){
    printf("Create Pipe Error!\n");
  }
  for(i=0; i<3; i++){
    if(0 > pipe(pipearr[i])){
      printf("Create Pipe Error!\n");
    }
  }

  //创建3个子进程
  for(i=0; i<3; i++){
    pid = fork();

    //创建子进程失败
    if((pid_t)0 > pid){
      printf("Fork Error!\n");
      return 3;
    }

    //子进程逻辑
    if((pid_t)0 == pid){
      //发送格式化数据给主进程
      FILE *f;
      f = fdopen(pipefd[1], "w");
      fprintf(f, "I am %d\n", getpid());
      fclose(f);

      //接收父进程发过来的数据
      read(pipearr[i][0], buff, 20);
      printf("MyPid:%d, Message:%s", getpid(), buff);

      //完成后及时退出循环，继续循环会出大问题，和fork的运行逻辑有关！
      break;
    }
  }

  //主进程逻辑
  if((pid_t)0 < pid){
    //循环接收所有子进程发过来的数据，并且返回数据给子进程
    for(i=0; i<3; i++){
      //接收子进程发来的数据
      read(pipefd[0], buff, 20);
      printf("MyPid:%d, Message:%s", getpid(), buff);

      //发送数据给子进程
      write(pipearr[i][6], "Hello My Son\n", 14);
    }
    sleep(3);
  }

  return 0;
}

编译后的运行效果如下：

简单说一下上面的程序逻辑：

首先是有两种管道

• 第一种只有一个：创建的3个子进程都往这里面写，主进程从这里面读取数据

• 第二种有一组，每个子进程一个：主进程分别往3个管道中写，每个子进程对应从属于自己的管道中读

针对第二种，很明显一个写，一个读，可以保证并发安全。但第一种呢，多个子进程都往一个管道里面写，会不会有问题，这个需要特别注意：

• 当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性

• 当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性

上面多个子进程同时往pipefd中写入的数据小于PIPE_BUF，所以是原子性的，另外只有主进程一个进程在读，所以可以保证数据的完整性。在webbench中其实就是这样使用管道的

可以编译下面的程序，查看PIPE_BUF的值

#include <stdio.h>
#include <limits.h>

int main()
{
  printf("PIPE_BUF = %d\n", PIPE_BUF);

  return 0;
}

编译后运行效果如下：