【Linux】第三十站：进程间通信

一、是什么

两个或者多个进程实现数据层面的交互

因为进程独立性的存在，导致进程通信的成本比较高

通信是有成本的，体现在要打破进程独立性

二、为什么

1. 基本数据
2. 发送命令
3. 实现某种协同
4. 通知
5. …

最终都是要通信起来

三、怎么办

1. 进程间通信的本质：必须让不同的进程看到同一份“资源”

2. “资源”：特定形式的内存空间

3. 这个”资源“谁提供？一般是操作系统，为什么不是我们两个进程中的一个呢？假设是由一个进程提供的，那么这个资源属于谁？属于这个进程独有。这样会破坏进程独立性。所以由操作系统也就是第三方空间提供。

4. 所以我们进程访问这个空间，进行通信，本质就是访问操作系统！

进程代表的就是用户。”资源“从创建，使用，释放，都是有系统调用接口的！！

• 所以从底层设计，从接口设计，都要由操作系统独立设计

• 一般操作系统会有一个独立的通信模块----隶属于文件系统 -----IPC(进程间通信)通信模块

• 需要定制标准 ---- 进程间通信是有标准的 ----- system V && posix

  system V用于本机内部通信，而posix用于网络的通信

  system V的通信方式有如下：消息队列，共享内存，信号量

  posix的通信方式有：消息队列，共享内存，信号量，互斥量，条件变量，读写锁

5. 还有一种方式是基于文件级别的通信方式 ---- 管道

四、管道

1.什么是管道

如果一个文件被可以多个进程打开，那么这个文件就可以作为公共资源，一个读，一个写即可

所谓的管道就是类似的基于文件级别的通信方式

管道是Unix中最古老的进程间通信的形式。

我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”

如下所示，我们知道这样的竖划线其实也是管道

其实就是who进程的数据写到了管道里面，然后wc进程的数据需要从管道支中读取

2.管道的原理

如下图所示，当我们启动了一个进程以后，自然而然就要创建test_strcut对象，然后这里面会有一个指针指向文件描述符表，在这个表中会有一个指针数组，它的下标就是文件描述符，其中0，1，2号文件描述符要被默认打开的标准输入，标准输出，标准错误三个流所占用，值得注意的是，显示器本来只有一个，但是我们这里为了方便，画成了两个

然后当我们未来新打开一个文件以后，就会创建一个新的struct file，并将最小的没有被使用的下标作为这个的文件描述符，然后会返回这个文件描述符

然后在这个struct file中，有inode用于寻找文件属性，有file_operators用于实现一切皆文件，还有一个缓冲区

在磁盘中，也会在特定的分区特定的分组有对应的数据块和属性块，供我们读写，如果写的时候，一旦对应的位置为脏，那么就会往回刷新过去，从而进行写入。

（即打开文件的时候，因为struct file本身就会创建一个struct inode，这个inode里面就是文件的属性，供我们查看，这个inode里面的会直接从磁盘当中的inode里面加载。缓冲区则是磁盘当中的数据要先加载到这个缓冲区中，当我们利用file_operators的方法去修改缓冲区以后，就是数据为脏了，然后就会将这个数据刷新回磁盘）

而现在，我们让创建的这个文件在磁盘当中并不存在，但是有对应的inode，file_operators，缓冲区。

即只要有左半边的功能即可，这样他就是一个内存级别的文件

而现在，当我们这个进程在创建子进程的时候，它肯定会创建一个PCB，然后对应的文件描述符表也会拷贝一份。这两份文件描述符表的内容是一模一样的，左边的都是属于进程的，而右边的是属于文件的，不需要拷贝也不会拷贝。

正是由于这两个文件描述符表一模一样，所以才导致了我们父子进程会在同一个文件中打印。

而上面的这个过程，最终会导致，我们新开的这个文件也会被两个进程都指向

而我们前面所说的进程间通信，本质前提是需要先让不同的进程，看到同一份资源！！

这样我们就可以利用这个文件实现进程间通信了！

这就是管道的一个比较朴素的原理

所以管道其实就是文件

而且在这里会由于有引用计数，即便父进程关闭了这个文件，也不会消失的

在这里如果我们父进程只有只读方式打开，那么这个文件描述符表继承下来的时候也是只读方式，这就没法通信了。所以其实父进程在打开文件的时候，会把文件以读写方式都打开一遍。这样的话就是下面的原理了！

---

如下图所示，当我们的task_struct要将同一个文件分别以读写的方式打开的时候，会分别创建对应的struct file，只不过他们里面的inode，文件缓冲区，等等都是一样的，只是权限不同。

然后我们继续创建子进程就是如下所示

像上面的这种，我们只想用来实现单向通信的

假设现在，我们想让子进程进行写入，父进程进行读取

当我们想要子进程写入，父进程读取的时候，只需要关闭对应的读写端即可

此时，两个struct file的引用计数都会变为1,也不可能会再次产生影响

这就是管道的原理

正式因为这个只能进行单向通信，所以才将它称作管道

那么如果要双向通信呢？

我们可以创建多个管道，比如两个管道就可以了

那么这两个进程如果没有任何关系，可以用我们上面的原理进行通信吗？

不能。必须是父子关系，兄弟关系，爷孙关系…

总之必须是具有血缘关系的进程，只不过常用于父子

那么我们这个文件有名字，路径…吗？即下面这部分

答案是没有的，它根本不需要名字，更不需要怎么标定它，因为它是通过继承父进程的资源来得到的。

所以我们把这种管道的名字叫做匿名管道

当然至此我们还没有通信，我们前面所做的工作都是建立通信信道，那么为什么这么费劲呢？这是因为进程具有独立性，通信是有成本的

3.接口

int pipe(int pipefd[2])

上面这个系统调用，它的作用就是创建一个管道

如果成功的话，返回0，如果错误，返回-1，并且错误码errno被设置

那么它的参数是什么意思呢？

这个参数其实是一个输出型参数

也就是说，调用这个pipe以后，父进程就会以读写方式打开一个内存级文件了

打开以后，它的工作就完了

所以这个参数的意思就是，创建好内存级文件以后，就会把对应的两个文件描述符给带出来，供用户使用！！！

其中，一般pipefd[0]是读下标，pipefd[1]是写下标

4.编码实现

在如下代码中运行结果为

#include <iostream>
#include <unistd.h>
#define N 2
using namespace std;

int main()
{
    int pipefd[N] = {0};
    int n = pipe(pipefd);
    if(n < 0) return 1;
    std::cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << std::endl;
    return 0;
}

如下代码是一个简单的实现管道间的通信

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstring>

#define N 2
#define NUM 1024

using namespace std;

void Writer(int wfd)
{

    string s = "hello I am child";
    pid_t self = getpid();
    int number = 0;
    char buffer[NUM];
    while(1)
    {
        //构建发送字符串
        buffer[0] = 0;
        snprintf(buffer, sizeof(buffer), "%s-%d-%d", s.c_str(), self, number++);
        //cout << buffer;
        
        //发送给父进程
        write(wfd, buffer, strlen(buffer));
        sleep(1);
    }
}
void Reader(int rfd)
{
    char buffer[NUM];
    while(1)
    {
        buffer[0] = 0;
        ssize_t n = read(rfd, buffer, sizeof(buffer));
        if(n > 0)
        {
            buffer[n] = 0;
            cout << "father get a message : ["<<buffer << "]" << endl;           
        }
    }
}

int main()
{
    int pipefd[N] = {0};
    int n = pipe(pipefd);
    if(n < 0) return 1;
    // std::cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << std::endl;
    
    pid_t id = fork();
    if(id < 0)
    {
        return 2;
    }
    else if(id == 0)
    {
        //child
        close(pipefd[0]);
    
        Writer(pipefd[1]);
    
        close(pipefd[1]);
        exit(0);
    }
    //father
    close(pipefd[1]);
    Reader(pipefd[0]);

    pid_t rid = waitpid(id, NULL, 0);
    if(rid < 0) return 3;

    close(pipefd[0]);
    return 0;
}

5.管道的特征

1. 具有血缘关系的进程进行进程间通信

2. 管道只能单向通信

3. 父子进程是会协同的，同步与互斥的，是为了保护管道文件的数据安全

因为该资源是不同的多执行流共享的，难免会出现访问冲突的问题，这也就是临界资源竞争的问题

如下所示，父子进程并没有出现，子进程执行一条，而父进程执行很多条的情况，虽然父进程中并没有每隔一秒打印一次的代码，但是会跟子进程写入的速度差不多。

4. 管道是面向字节流的

5. 管道是基于文件的，而文件的生命周期是随进程的！

6.管道的四种情况

1. 读写端正常，管道如果为空，读端就要阻塞

2. 读写端正常，管道如果被写满，写端就要被阻塞

从这里也能得到，管道是有固定大小的

我们可以先用下面这个命令观察一下，这个命令的功能是查看一些数据的最大限制

ulimit -a

在这里我们可以看到，管道一共有512 * 8 == 4KB大小

那么我们可以来测试一下是不是这么大呢？

我们让写端的代码为如下，读端不去读。

运行结果为如下，65535

即一共有64KB。

那我们前面的4KB是什么呢？

其实管道的大小在不同的内核中是不同的。

当前我们系统的管道大小是64KB

现在回答前面的4KB究竟是什么，这是因为我们写端在写入数据以后，读端要读数据，但是不能写了一半就读走了，这样可能导致数据出现问题。所以要么就不读，要么一次全读完， 也就是PIPE_BUF就是要保证是一个原子性的最大长度。不能被打断的，而这个PIPE_BUF就是4KB，也就是前面查到的4KB。

3. 读端正常读，写端关闭，读端就会读到0，表明读到了文件（pipe）结尾，不会被阻塞

运行结果为

前五秒正常读取，后面直接输出0

所以这个代码应该改为

运行结果为

4. 写端正常写入，读端关闭了。操作系统就要杀掉正在写入的进程

因为操作系统是不会去做，低效，浪费等类似的工作的，如果做了，就是操作系统的bug

那么如果干掉这个进程呢？通过信号杀掉

而我们前面的这个样例就是子进程写入，父进程读取。我们可以用如下代码来做一个小实验

 #include <iostream>
 #include <unistd.h>
 #include <cstdlib>
 #include <cstdio>
 #include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <cstring>

 #define N 2
 #define NUM 1024

 using namespace std;

 void Writer(int wfd)
 {

     string s = "hello I am child";
     pid_t self = getpid();
     int number = 0;
     char buffer[NUM];
     while(1)
     {
         //构建发送字符串
         buffer[0] = 0;
         snprintf(buffer, sizeof(buffer), "%s-%d-%d", s.c_str(), self, number++);
         //cout << buffer;

         //发送给父进程
         write(wfd, buffer, strlen(buffer));
         sleep(1);
         // sleep(1);        
         // char c = 'c';
         // write(wfd, &c, 1);
         // cout << number++ <<endl;
         // if(number >= 5) break;
     }
 }
 void Reader(int rfd)
 {
     char buffer[NUM];
     int cnt = 5;
     while(cnt--)
     {
         buffer[0] = 0;
         ssize_t n = read(rfd, buffer, sizeof(buffer));
         if(n > 0)
         {
             buffer[n] = 0;
             cout << "father get a message : ["<<buffer << "]" << endl;   
         }
         //cout << "n :" << n << endl; 
         else if(n == 0)
         {
             cout << "father read file done ...." <<endl;
             break;
         }
         else break;

     }
 }

 int main()
 {
     int pipefd[N] = {0};
     int n = pipe(pipefd);
     if(n < 0) return 1;
     // std::cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << std::endl;

     pid_t id = fork();
     if(id < 0)
     {
         return 2;
     }
     else if(id == 0)
     {
         //child
         close(pipefd[0]);

         Writer(pipefd[1]);

         close(pipefd[1]);
         exit(0);
     }
     //father
     close(pipefd[1]);
     Reader(pipefd[0]);
     close(pipefd[0]);
     cout << "father close read fd" << pipefd[0] <<endl;
     sleep(5); // 为了维持一段时间的僵尸

     int status = 0; 
     pid_t rid = waitpid(id, &status, 0);
     if(rid < 0) return 3;
     cout << "wait child success: " << rid << "exit code: " << ((status>>8)&0xFF) << "exit signal: " << (status&0x7F) <<endl;

     sleep(5);
     cout << "father quit" <<endl;


     return 0;
 }

最终运行结果为如下

可见与我们上面所说的是一致的

我们也可以注意到，这个子进程退出的原因是13号信号