【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日
    浏览(31)
  • 【Linux】第十站:git和gdb的基本使用

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

    2024年02月05日
    浏览(37)
  • 【Linux】进程通信之管道通信详解

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

    2023年04月19日
    浏览(39)
  • 【Linux】进程通信之匿名管道通信

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

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

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

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

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

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

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

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

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

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

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

    2024年04月29日
    浏览(35)
  • Linux——进程间通信、管道

    进程间的通信就是 在不同进程之间传播或交换信息。 举个例子: 古时,两军交战不斩来使; 因为两军互相是独立的,所以使节就是两军之间传话的进行传话的; 而在OS中,进程之间也是相互独立的,但某项工作并不是一个进程就可以完成,而是多个进程之间相互协助完成;

    2024年02月22日
    浏览(38)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包