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

这篇具有很好参考价值的文章主要介绍了【Linux】第三十站:进程间通信。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、是什么

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

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

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

二、为什么

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

最终都是要通信起来

三、怎么办

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

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

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

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

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

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

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

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

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

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

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

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

四、管道

1.什么是管道

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

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

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

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

2.管道的原理

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

所以管道其实就是文件

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言


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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

这就是管道的原理

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

那么如果要双向通信呢?

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

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

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

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

3.接口

int pipe(int pipefd[2])

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

  1. 管道是面向字节流的

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

6.管道的四种情况

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

ulimit -a

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

运行结果为如下,65535

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

即一共有64KB。

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

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

运行结果为

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

所以这个代码应该改为

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

运行结果为

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

  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;
 }


最终运行结果为如下

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言

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

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

【Linux】第三十站:进程间通信,【Linux】,linux,php,运维,c++,git,服务器,开发语言文章来源地址https://www.toymoban.com/news/detail-828815.html

到了这里,关于【Linux】第三十站:进程间通信的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux】Linux进程间通信(三)

    ​ ​📝个人主页:@Sherry的成长之路 🏠学习社区:Sherry的成长之路(个人社区) 📖专栏链接:Linux 🎯 长路漫漫浩浩,万事皆有期待 上一篇博客:【Linux】Linux进程概念 管道通信本质是基于文件的,也就是说操作系统并没有为此做过多的设计工作,而system V IPC是操作系统特

    2024年02月05日
    浏览(34)
  • 【Linux】第十站:git和gdb的基本使用

    如下所示,是我们的新建仓库时候的注意事项 我们需要注意的是 我们要选择开源 对于这个初始化仓库,我们现在可选可不选,选的话按照我们当前的语言即可,这个.gitignore这个文件的作用如果文件后缀与文件里面的相同的话,是不会被选择提交的,而是忽略的,因为我们提

    2024年02月05日
    浏览(39)
  • 【Linux】进程通信之匿名管道通信

    我们往往需要多个进程协同,共同完成一些事情。 数据传输:一个进程需要将它的数据发送给另一个进程 资源共享:多个进程之间共享同样的资源。 通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止 时要通知父进程)。

    2024年04月14日
    浏览(46)
  • 【Linux】进程通信之管道通信详解

    🍎 作者: 阿润菜菜 📖 专栏: Linux系统编程 其实管道通信是Unix中最古老的进程间通信的形式了: 管道通信是一种进程间通信的方式,它可以让一个进程的输出作为另一个进程的输入,实现数据的传输、资源的共享、事件的通知和进程的控制。 管道通信分为两种类型:匿名

    2023年04月19日
    浏览(41)
  • 【Linux C | 进程】Linux 进程间通信的10种方式(1)

    😁博客主页😁:🚀https://blog.csdn.net/wkd_007🚀 🤑博客内容🤑:🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭 🤣本文内容🤣:🍭介绍 🍭 😎金句分享😎:🍭你不能选择最好的,但最好的会来选择你——泰戈尔🍭 本文未经允许,不得转发!!! 下表是进程间通

    2024年01月25日
    浏览(37)
  • 【Linux C | 进程】Linux 进程间通信的10种方式(2)

    😁博客主页😁:🚀https://blog.csdn.net/wkd_007🚀 🤑博客内容🤑:🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭 🤣本文内容🤣:🍭介绍 🍭 😎金句分享😎:🍭你不能选择最好的,但最好的会来选择你——泰戈尔🍭 本文未经允许,不得转发!!! POSIX消息队列与

    2024年02月20日
    浏览(33)
  • Linux--进程间的通信--进程池

    进程间的通信–匿名管道 进程池是一种将多个进程组织起来以执行特定任务的机制 。 它由多个预先创建好的资源进程和一个管理进程组成。这些资源进程被管理进程负责分配和调度,用于处理任务 。 当有新的任务提交时,管理进程会从进程池中取出一个资源进程,将任务

    2024年04月25日
    浏览(37)
  • 【Linux系统】理解Linux中进程间通信

    进程间通信(IPC,Interprocess communication)是一组编程接口,让程序员能够协调不同的进程,使之能在一个操作系统里同时运行,并相互传递、交换信息。这使得一个程序能够在同一时间里处理许多用户的要求。因为即使只有一个用户发出要求,也可能导致一个操作系统中多个

    2023年04月21日
    浏览(37)
  • Linux多进程(二)进程通信方式一 管道

    管道的是进程间通信(IPC - InterProcess Communication)的一种方式,管道的本质其实就是内核中的一块内存(或者叫内核缓冲区),这块缓冲区中的数据存储在一个环形队列中,因为管道在内核里边,因此我们不能直接对其进行任何操作。 因为管道数据是通过队列来维护的,我们先

    2024年04月29日
    浏览(36)
  • Linux进程通信——共享内存

    两个进程的PCB创建虚拟地址空间然后映射到物理内存中,每个进程因为是独立的,所以在物理内存中的地址也不同。 那么共享内存是怎么做到的呢? 首先先在物理内存中申请一块内存。 然后讲这块内存通过页表映射分别映射到这两个进程的虚拟地址空间内,让这两个进程都

    2024年02月01日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包