进程间通信介绍

概念

进程间通信简称为IPC是一组编程接口，让程序员能够协调不同的进程，使之能在一个操作系统中同时运行，并互相传递，交换信息。这使得一个程序能够在同一时间里处理许多用户的要求。IPC方法包括管道，消息排队，旗语，共用内存以及套接字(本篇博客只介绍共享内存和管道).

目的

数据传输:一个进程需要将它的数据发送给另一个进程
资源共享:多个进程之间共享同样的资源
通知事件:一个进程需要向另一个或一组进程发送消息，通知它发生了某种事件，比如进程终止时需要通知其父进程
进程控制:有些进程希望完全控制另一个进程的执行，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

本质

进程间通信的本质就是，让不同的进程看到同一份资源。

由于各个运行进程之间具有独立性，这个独立性主要体现在数据方面，而代码逻辑层面可以私有也可以共有，因此各个进程之间要实现通信是很困难的。

各个进程之间若想实现通信，一定要借助第三方资源，这些进程就可以通过向这个第三方资源写入或读取数据，进而实现进程之间的通信，这个第三方资源实际上就是操作系统提供的一段内存区域。

因此，进程间通信的本质就是，让不同的进程看到同一份资源，由于这份资源可以由操作系统中的不同模块提供，因此出现了不同的进程间通信方式。

管道

什么是管道

概念:管道是UNIX中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个"管道"。它的特点就是单向传输数据的，先进先出。

例如，统计我们当前使用云服务器上的登录用户个数。

其中，who命令和wc命令是两个程序，当运行起来就变成两个进程，who进程通过便准输出将数据打到管道中，wc进程再通过标准输入从管道当中读取数据。至此便完成了数据的传输，进而完成数据的进一步加工处理。(who命令用于查看当前云服务器的登录用户(一行一个用户),wc -l用于统计当前的行数)

匿名管道

匿名管道的原理

匿名管道用于进程间通信，且仅限于本地父子进程之间的通信。

进程间通信的本质就是，让不同的进程看到同一份资源，使用匿名管道实现父子进程间通信的原理就是，让两个父子进程先看到同一份被打开的文件资源，然后父子进程就可以对该文件进行写入或是读取操作，进而实现父子进程间通信。

注意:

这里父子进程看到的同一份文件资源是由操作系统来维护的，所以当父子进程对该进程进行写入操作时，该文件缓冲区当中的数据是不会进行写时拷贝的。
管道虽然用的是文件的方案，但操作系统一定不会把进程进行通信的数据刷新到磁盘当中，因为这样做有IO参与会降低效率。也就是说，这种文件是一批不会把数据写到磁盘当中的文件，换句话说，磁盘文件和内存文件不一定是一一对应的,有些文件只会在内存当中存在，而不会在磁盘中存在。

pipe函数

pipe函数用于创建匿名管道，pip函数的函数原型如下:

int pipe(int pipefd[2]);

pipe函数的参数是一个输出型参数，数组pipefd用于返回两个指向管道读端和写端的文件描述符

数组元素	含义
pipefd[0]	管道读端的文件描述符
pipefd[1]	管道写端的文件描述符

pipe函数调用成功时返回0，调用失败时返回-1。

匿名管道使用步骤

在创建匿名管道实现父子进程间通信的过程中，需要pipe函数和fork函数搭配使用，具体步骤如下:

父进程调用pipe函数创建管道
2.父进程创建子进程
3.父进程关闭写端，子进程关闭读端
注意:

管道只能够进行单向通信，因此当父进程创建完子进程后，需要确认父子进程谁读谁写，然后关闭相应的读写端。
从管道写端写入的数据会被内核缓冲，直到从管道的读取被读取。

从文件描述符的角度再来看看这三个步骤:

父进程调用pipe函数创建管道
2.父进程创建子进程
3.父进程关闭写端，子进程关闭读端
在以下代码中，子进程向匿名管道当中写入10行数据，父进程向匿名管道读出数据。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{    //创建匿名管道
  int pipefd[2]={0};
    if(pipe(pipefd)<0)
    {
     perror("pipe error!\n");
     exit(-1);
     }
     //创建子进程
     pid_t id=fork();
     if(id<0)
     {
      perror("fork error!\N");
      exit(-1);
      }
      else if(id==0)
      {
       //子进程关闭读端
       close(pipefd[0]);
        const char* msg="I am child...!\n";
        int count=10;
       while(count--)
       {
        write(pipefd[0],msg,strlen(msg]);
         sleep(1);
        }
    }
     else 
    {
     //关闭写端
      close(pipefd[1]);
      char buf[64];
      while(1)
      {
        ssize_t s=read(pipefd[0],buf,sizeof(buf)/sizeof(buf[0]);
         if(s>0)
       {
        buf[s]=0;
        printf("father get message:%s",buf);
       }
       else if(s==0)
        {
          printf("father read end of file...\n");
         }
         sleep(1);
        }
}
  return 0;
}

运行结果如下:

管道读写规则

以四种情况来进行研究:

1.写端速度小于读端速度，管道大部分时间内为空，即读条件不满足让子进程每5秒写一次，父进程一直在读，观察现象

代码如下:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipefd[2];
  int ret = pipe(pipefd);
  if (ret == -1){
    // 管道创建失败
    perror("make piep");
    exit(-1);
  }
  pid_t id = fork();
  if (id < 0){
    perror("fork failed");
    exit(-1);
  }
  else if (id == 0){
    // child
    // 关闭读端
    close(pipefd[0]);
    const char* msg = "I am child...!\n";
    //int count = 0;
    // 写数据
    while (1){
      ssize_t s = write(pipefd[1], msg, strlen(msg));
      sleep(5);// 管道大部分时间是空的，读条件不满足时，读端处于阻塞状态
      printf("child is sending message...\n");
    }
  }
  else{
    // parent
    close(pipefd[1]);
    char buf[64];
    //int count = 0;
    while (1){
      ssize_t s = read(pipefd[0], buf, sizeof(buf)/sizeof(buf[0])-1);
      if (s > 0){
        buf[s] = '\0';// 字符串后放一个'\0'
        printf("father get message:%s", buf);
      }
      else if (s == 0){
        // 读到文件结尾  写端关闭文件描述符 读端会读到文件结尾
        printf("father read end of file...\n ");
      }
    }
  }
  return 0;
}

运行结果:读端处于阻塞

总结:当读条件不满足时，读端进程会处于阻塞，从task_struct会从运行队列调到等待队列，知道数据来才会转移到运行队列中

2.写端速度大于读端速度，管道大部分时间内是满的，即写调整不满足 让子进程一直写，父进程每3秒读一次，观察现象

代码改造:

pid_t id = fork();
if (id < 0){
  perror("fork failed");
  exit(-1);
}
else if (id == 0){
  // child
  // 关闭读端
  close(pipefd[0]);
  const char* msg = "I am child...!\n";
  //int count = 0;
  // 写数据
  while (1){
    ssize_t s = write(pipefd[1], msg, strlen(msg));
    printf("child is sending message...\n");
  }
}
else{
  // parent
  close(pipefd[1]);
  char buf[64];
  //int count = 0;
  while (1){
    ssize_t s = read(pipefd[0], buf, sizeof(buf)/sizeof(buf[0])-1);
    if (s > 0){
      buf[s] = '\0';// 字符串后放一个'\0'
      printf("father get message:%s", buf);
      sleep(5);// 管道大部分时间都是满的，写条件不满足时，写端处于阻塞状态
    }
    else if (s == 0){
      // 读到文件结尾  写端关闭文件描述符 读端会读到文件结尾
      printf("father read end of file...\n ");
    }
  }
}

运行结果: 写端写了一会，管道满了，此时写端处于阻塞

3.关闭写端 让写端先写5秒，然后关闭写端，观察现象

// child
// 关闭读端
close(pipefd[0]);
const char* msg = "I am child...!\n";
int count = 0;
// 写数据
while (1){
  ssize_t s = write(pipefd[1], msg, strlen(msg));
  printf("child is sending message...\n");
  printf("CHILD: %d\n", count++);
  if (count == 5){
    close(pipefd[1]);
    exit(-1);
 }
  sleep(1);
}
// parent
close(pipefd[1]);
char buf[64];
while (1){
  ssize_t s = read(pipefd[0], buf, sizeof(buf)/sizeof(buf[0])-1);
  if (s > 0){
    buf[s] = '\0';// 字符串后放一个'\0'
    printf("father get message:%s", buf);
    sleep(5);// 管道大部分时间都是满的，写条件不满足时，写端处于阻塞状态
  }
  else if (s == 0){
    // 读到文件结尾  写端关闭文件描述符 读端会读到文件结尾
    printf("father read end of file...\n ");
   }
}

运行结果:5秒后，关闭写端，读端会读到文件结尾

如果关闭写端，读端进程会读到文件结尾

4.关闭读端 3秒后关闭读端

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipefd[2];
  int ret = pipe(pipefd);
  if (ret == -1){
    // 管道创建失败
    perror("make piep");
    exit(-1);
  }
  pid_t id = fork();
  if (id < 0){
    perror("fork failed");
    exit(-1);
  }
  else if (id == 0){
    // child
    // 关闭读端
    close(pipefd[0]);
    const char* msg = "I am child...!\n";
    // int count = 0;
    // 写数据
    while (1){
      ssize_t s = write(pipefd[1], msg, strlen(msg));
      printf("child is sending message...\n");
      sleep(1);
    }
  }
  else{
    // parent
    close(pipefd[1]);
    char buf[64];
    int count = 0;
    while (1){
      ssize_t s = read(pipefd[0], buf, sizeof(buf)/sizeof(buf[0])-1);
      if (s > 0){
        buf[s] = '\0';// 字符串后放一个'\0'
        printf("father get message:%s", buf);
        //sleep(5);// 管道大部分时间都是满的，写条件不满足时，写端处于阻塞状态
      }
      else if (s == 0){
        // 读到文件结尾  写端关闭文件描述符 读端会读到文件结尾
        printf("father read end of file...\n ");
      }
      sleep(1);
      if (count++ == 3){
        close(pipefd[0]);// 读端关闭文件描述符，写端进程后序会被操作系统直接杀掉，没有进程读，写时没有意义的
        break;
      }
    }
    int status;
    pid_t ret = waitpid(id, &status, 0);
    if (ret > 0){
      // 等待成功
      printf("child exit singal is %d\n", status&0x7f);
    }
    else{
      // 等待失败
      perror("wait failed");
      exit(-1);
    }
  }
  return 0;
}

运行结果:关闭读端后，子进程收到操作系统发送的13个信号杀死

读端关闭，写端进程会被操作系统发送信号杀死。

总结:管道是自带同步与互斥机制的，读端进程和写端进程是有一个步调协调的过程的，不会说当管道没有数据了读端还在读取，而当管道已经满了写端还在写入。读端进程读取数据的条件是管道里面有数据，写端进程写入数据的条件是管道当中还有空间，若是条件不满足，则相应的进程就会被挂起，直到条件满足后才会被再次唤醒。

1.当没有数据可读时:

O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来为止。

2.当管道满的时候

O_NONBLOCK disable：write调用阻塞，直到有进程读走数据

O_NONBLOCK enable：write调用返回-1，errno值为EAGAIN。

3.如果所有管道写端对应的文件描述符被关闭，则read返回0

4.如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE，进而可能导致write进程退出。

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

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

管道的特点

管道内部自带同步与互斥机制

我们将一次只允许一个进程使用的资源，称为临界资源。管道在同一时刻只允许一个进程对其进行写入或读取操作，因此管道也就是一种临界资源。

临界资源需要被保护的,若是我们不对管道这种临界资源进行任何保护机制，那么就可能会出现同一时刻有多个进程对同一管道进行操作的情况，进而导致同时读写，交叉读写以及读取到的数据不一致等问题。

为了避免这些问题，内核会对管道操作进行同步与互斥:

同步:两个或两个以上的进程在运行过程中协同步调，按预定的先后次序运行。比如:A任务运行依赖于B任务产生的数据
互斥:一个公共资源同一时刻只能被一个进程使用，多个进程不能同时使用公共资源。

实际上，同步是一种更为复杂的互斥，而互斥是一种特殊的同步。对于管道的场景来说，互斥就是两个进程不可以同时对管道进行操作，它们会相互排斥，必须等一个进程操作1完毕，另一个才能操作，而同步也是指这两个不能同时对管道进行操作，但这两个进程必须要按照某种次序来对管道进行操作。

也就是说，互斥具有唯一性和排它性，但互斥并不限制任务的运行顺序，而同步的任务之间则有明确的顺序关系。

2.管道的生命周期随进程

管道本质是通过文件进行通信的，也就是说管道依赖于文件系统，那么当所有该文件的进程都退出后，该文件也会被释放掉，所以说管道的生命周期随进程。

3.管道提供的是流式服务

对于进程A写入管道当中的数据，进程B每次从管道读取的数据多少是任意的，这种被称为流式服务，与之相对应的是数据报服务:

流式服务:数据没有明确的分割，不分一定的报文段。
数据报服务:数据有明确的分割，拿数据按报文段拿。

4.管道是半双工通信的

在数据通信中，数据在线路上的传送方式可以分为以下三种:

单工通信:单工模式的数据传输是单向的。通信双方中，一方固定为发送端，另一方固定为接收端。
半双工通信:半双工数据传输数据可以在一个信号载体的两个方向上传输，但是不能同时传输。
全双工通信:全双工通信允许数据在两个方向上同时传输，它的能力相当于两个单工通信方式的结合。全双工可以同时(瞬时)进行信号的双向传输。

管道是半双工的，数据只能向一个方向流动，需要双方通信时，需要建立起两个管道。

管道的大小

管道的容量是有限的，如果管道满了。那么写端将阻塞或失败，那么管道的最大容量是多少?

方法一:代码测试

若读端进程一直不读取管道中的数据，写端进程一直向管道写入数据，当管道被写满后，写端进程就会被挂起。据此，可以写入代码来测试管道的最大容量。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
  int fd[2] = { 0 };
  if (pipe(fd) < 0){ //使用pipe创建匿名管道
    perror("pipe");
    return 1;
  }
  pid_t id = fork(); //使用fork创建子进程
  if (id == 0){
    //child 
    close(fd[0]); //子进程关闭读端
    char c = 'a';
    int count = 0;
    //子进程一直进行写入，一次写入一个字节
    while (1){
      write(fd[1], &c, 1);
      count++;
      printf("%d\n", count); //打印当前写入的字节数
    }
    close(fd[1]);
    exit(0);
  }
  //father
  close(fd[1]); //父进程关闭写端
  //父进程不进行读取
  waitpid(id, NULL, 0);
  close(fd[0]);
  return 0;
}

可以看到，在读端进程不读取的情况下，写端进程最多写65536字节的数据就被操作系统挂起，意思就是当前Linux版本中管道的最大容量为65536字节。

方法二:使用man手册

根据man手册，在2.6.11之前的Linux版本中，管道的最大容量与系统页面大小相同，从Linux2.6.11往后，管道的最大容量是65536字节。

【Linux篇】第十二篇——进程间通信（管道+system V共享内存）（一）

进程间通信介绍

概念

目的

本质

分类

管道

什么是管道

匿名管道

匿名管道的原理

pipe函数

匿名管道使用步骤

管道读写规则

管道的特点

管道的大小

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像