Linux第三十站:进程间通信

文章目录

  • 一、是什么
  • 二、为什么
  • 三、怎么办
  • 四、管道
    • 1.什么是管道
    • 2.管道的原理
    • 3.接口
    • 4.编码实现
    • 5.管道的特征
    • 6.管道的四种情况

一、是什么

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

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

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

二、为什么

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

最终都是要通信起来

三、怎么办

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

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

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

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

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

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

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

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

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

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

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

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

四、管道

1.什么是管道

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

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

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

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

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

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

image-20240117165008872

2.管道的原理

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

image-20240117165711790

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

image-20240117170058655

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

image-20240117175441181

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

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

image-20240117175659808

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

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

image-20240117180745727

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

image-20240117182014755

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

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

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

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

image-20240117182516479

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

所以管道其实就是文件

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

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

image-20240117183304881


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

image-20240117184102300

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

image-20240117184324948

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

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

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

image-20240117185001529

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

这就是管道的原理

image-20240117185124261

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

那么如果要双向通信呢?

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

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

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

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

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

image-20240117185854655

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

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

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

3.接口

int pipe(int pipefd[2])

image-20240117190247538

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

如果成功的话,返回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;
}

image-20240117224519424

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

#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. 父子进程是会协同的,同步与互斥的,是为了保护管道文件的数据安全

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

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

image-20240118140633184

  1. 管道是面向字节流的

  2. 管道是基于文件的,而文件的生命周期是随进程的!

6.管道的四种情况

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

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

image-20240118142148692

image-20240118142255319

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

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

ulimit -a

image-20240118144756461

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

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

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

image-20240118145108454

运行结果为如下,65535

image-20240118145136915

即一共有64KB。

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

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

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

image-20240118145405418

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

  1. 读端正常读,写端关闭,读端就会读到0,表明读到了文件(pipe)结尾,不会被阻塞

image-20240118151358927

运行结果为

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

image-20240118151430826

所以这个代码应该改为

image-20240118151754782

运行结果为

image-20240118151821278

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

因为操作系统是不会去做,低效,浪费等类似的工作的,如果做了,就是操作系统的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;
 }


最终运行结果为如下

image-20240118173345010

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

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

image-20240118173629917