【Linux】进程通信----管道通信(上)

简介: 【Linux】进程通信----管道通信(上)

> 作者:დ旧言~

> 座右铭:松树千年终是朽,槿花一日自为荣。

> 目标:理解进程通信----管道通信

> 毒鸡汤:有些事情,总是不明白,所以我不会坚持。早安!

> 专栏选自:Linux初阶

> 望小伙伴们点赞👍收藏✨加关注哟💕💕



🌟前言

当我们创建两个进程,希望它们可以相互沟通,我的内容你可以读,我的内容你可以写,这种联系我们就需要我们的管道,这个管道就可以达成两个进程或者更多进程相互通信,那这个关系在Linux中是如何实现的呢,我们又该如何理解呢?


⭐主体

学习【Linux】静态库和动态库咱们按照下面的图解:



🌙 什么是进程间通信


💫 进程间通信介绍

什么是进程间通信?

进程具有独立性,每个进程都有自己的PCB,所以进程间需要通信,并且通信的成本一定不低(通信的本质:OS需要直接或者间接给通信双方的进程提供“内存空间”,并且要通信的进程,必须看到一份公共的资源)

图解:



如何去通信

  • 采用标准的做法:System V进程间通信(聚焦在本地通信,如共享内存)、POSIX进程间通信(让通信过程可以跨主机)。
  • 采用文件的做法:管道-基于文件系统(匿名管道、命名管道)


管道通信的特点:

是面向字节流、占用内存空间、只能单向传输、有固定的大小和缓冲区等。

总结:

而我们所说的不同通信种类本质就是:上面所说的资源,是OS中的哪一个模块提供的。如文件系统提供的叫管道通信;OS对应的System V模块提供的…,(成本不低是因为我们需要让不同的进程看到同一份资源。


💫 进程间通信目的

进程间通信的目的:

  • 数据传输:一个进程需要将它的数据发送给另一个进程
  • 资源共享:多个进程之间共享同样的资源
  • 通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止时要通知父进程)
  • 进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程)


为什么要有进程间通信?

有时候我们需要多进程协同的,完成某种业务内容。比如管道。

图解:



💫 进程间通信分类

进程间通信分类:(匿名管道和命名管道)


  • 匿名管道是只能在父子进程间使用的,它通过pipe()函数创建,并返回两个文件描述符,一个用于读,一个用于写。
  • 命名管道是可以在任意进程间使用的,它通过mkfifo()或mknod()函数创建一个特殊的文件,然后通过open()函数打开,并返回一个文件描述符,用于读或写。


🌙 管道的实现和理解


💫 管道介绍

概念:

管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个"管道"


分析:


任何一个文件包括两套资源:1.file的操作方法 2.有属于自己的内核缓冲区,所以父进程和子进程有一份公共的资源:文件系统提供的内核缓冲区,父进程可以向对应的文件的文件缓冲区写入,子进程可以通过文件缓冲区读取,此时就完成了进程间通信,这种方式提供的文件称为管道文件。管道文件本质就是内存级文件,不需要IO。


两个进程如何看到同一个管道文件:fork创建子进程完成


管道创建时分别以读和写方式打开同一个文件(如果只读或者只写,子进程也只会继承只读或只写,父子双方打开文件的方式一样,无法完成单向通信);父进程创建子进程,父进程以读写打开,子进程也是以读写打开(一般而言,管道只用来进行单向数据通信);关闭父子进程不需要的文件描述符,完成通信。



💫 匿名管道

概念:

我们通过文件名区分文件,但是如果当前进程的文件没有名字,这样的内存级文件称为匿名管道。让两个进程看到同一个文件,通过父进程创建子进程,子进程继承文件地址的方式,看到同一个内存级文件,此时内存级文件没有名称就是匿名管道了。匿名管道能用来父进程和子进程之间进行进程间通信。


1.pipe

作用及其使用:

  • 创建一个管道只需要调用pipe,注意头文件,返回值,以及函数的参数。
  • 头文件为#include ,调用成功返回0,调用失败返回-1。参数是输出型参数。
SYNOPSIS
       #include <unistd.h>
       int pipe(int pipefd[2]);
DESCRIPTION
    pipe() creates a pipe,pipefd[0]  refers  to  the  read end of the pipe.  pipefd[1] refers to the write end of the pipe.
RETURN VALUE
       On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.


创建Makefile文件

mypipe:mypipe.cc
  g++ mypipe.cc -o mypipe
 
.PHONY:clean
clean:
  rm -f mypipe


创建管道文件,打开读写端

#include <iostream>
#include <unistd.h>
#include <cassert>
 
using namespace std;
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
 
    //0,1,2->3,4
    //[0]:读取  [1]:写入
    cout<<"fds[0]:"<<fds[0]<<endl;//3
    cout<<"fds[1]:"<<fds[1]<<endl;//4
    return 0;
}



因此,fds[0]:3代表读取,fds[1]:4代表写入;

fork子进程:

#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
 
    //fork
    pid_t id = fork();
    assert(id>=0);
    if(id==0)
    {
        //子进程通信
 
        exit(0);
    }
    //父进程通信
    n = waitpid(id,nullptr,0);
    assert(n==id);
    return 0;
}


关闭父子进程不需要的文件描述符,完成通信(子进程写入,父进程读取)

#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
using namespace std;
 
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    //fork
    pid_t id = fork();
    assert(id>=0);
    if(id==0)
    {
        //子进程通信:子进程进行写入,关闭读
        close(fds[0]);
        //通信
        const char*s = "这是子进程,正在进行通信";
        int cnt = 0;
        while(true)
        {
            cnt++;
            char buffer[1024];
            snprintf(buffer,sizeof buffer,"child->parent say:%s[%d][%d]",s,cnt,getpid());
            //写端写满的时候,在写会阻塞,等对方进行读取
            write(fds[1],buffer,strlen(buffer));//系统接口
            sleep(1);//一秒写一次
        }
        //退出前关闭子进程
        close(fds[1]);
        exit(0);
    }
    //父进程通信:父进程进行读取,关闭写
    close(fds[1]);
    //通信
    while(true)
    {
        char buffer[1024];
        //管道中如果没有数据,读端在读,默认会直接阻塞当前正在读取的进程
        ssize_t s = read(fds[0],buffer,sizeof(buffer)-1);
        if(s>0) buffer[s] = 0;
        cout<<"Get Message# "<<buffer<<"|mypid:"<<getpid()<<endl;
    }
 
    n = waitpid(id,nullptr,0);
    assert(n==id);
    
    //结束前关闭
    close(fds[0]);
    return 0;
}



2.读写特征

管道读写特征:

  • 1.读快写慢

分析:

  • 子进程休眠时,不在写入,父进程在读取(如果管道中没有数据,读端在读,此时默认会直接阻塞当前正在读取的进程)

代码:

#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    pid_t id = fork();
    assert(id >= 0);
    if (id == 0) // 子进程
    {
        // 子进程通信,关闭子进程的读取端,即子进程进行写入
        close(fds[0]);
        const char *s = "你好,我是子进程,正在进行通信";
        int cnt = 0;
        while (1)
        {
            cnt++;
            char buffer[1024];
            snprintf(buffer, sizeof buffer, "child -> parent say:%s [%d], [%d]", s, cnt, getpid());
            write(fds[1], buffer, strlen(buffer));
            sleep(50); // 每一秒写一次
        }
        close(fds[1]); // 退出子进程前关闭文件写入端
        exit(0);
    }
    // 父进程
    close(fds[1]); // 父进程关闭写入端,即父进程进行读取
    while (1)
    {
        char buffer[1024];
        printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
        printf("888888888888888888888888888888888888!!\n");
        if (s > 0)
            buffer[s] = 0;
        printf("Get Message : %s | mypid = %d\n", buffer, getpid());
    }
    n = waitpid(id, NULL, 0);
    assert(n == id);
    close(fds[0]); // 退出程序前,关闭读取端
    return 0;
}



  • 2.读慢写快

分析:

  • 读取管道的进程一直不进行读取,而写端一直在写入。写端可以向管道内写入,但是管道是固定大小的缓冲区,不断的只写不读管道会被写满。满了以后就不能再写入了,此时写端会处于阻塞状态。

文件mypipe.cc

#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
 
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    pid_t id = fork();
    assert(id >= 0);
    if (id == 0) // 子进程
    {
        // 子进程通信,关闭子进程的读取端,即子进程进行写入
        close(fds[0]);
        const char *s = "你好,我是子进程,正在进行通信";
        int cnt = 0;
        while (1)
        {
            cnt++;
            char buffer[1024];
            snprintf(buffer, sizeof buffer, "child -> parent say:%s [%d], [%d]", s, cnt, getpid());
            write(fds[1], buffer, strlen(buffer));
            printf("count: %d\n", cnt);
        }
        close(fds[1]); // 退出子进程前关闭文件写入端
        exit(0);
    }
    // 父进程
    close(fds[1]); // 父进程关闭写入端,即父进程进行读取
    while (1)
    {
        sleep(50); // 父进程不读
        char buffer[1024];
        ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
        printf("Get Message : %s | mypid = %d\n", buffer, getpid());
    }
    n = waitpid(id, NULL, 0);
    assert(n == id);
    close(fds[0]); // 退出程序前,关闭读取端
    return 0;
}



拓展:

如果休息sleep(2),这种情况,写端是将数据塞到管道内,管道读取是安装指定大小读取(并非一行一行的读取,最初安装一行来读取是因为写入的慢,一次只写一行数据,数据就被读取了)。


  • 3.写入关闭,读到0

子进程写入端关闭:

#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    pid_t id = fork();
    assert(id >= 0);
    if (id == 0) // 子进程
    {
        // 子进程通信,关闭子进程的读取端,即子进程进行写入
        close(fds[0]);
        const char *s = "你好,我是子进程,正在进行通信";
        int cnt = 0;
        while (1)
        {
            cnt++;
            char buffer[1024];
            snprintf(buffer, sizeof buffer, "child -> parent say:%s [%d], [%d]", s, cnt, getpid());
            write(fds[1], buffer, strlen(buffer));
            printf("count: %d\n", cnt);
            break;
        }
        close(fds[1]); // 退出子进程前关闭文件写入端
        exit(0);
    }
    // 父进程
    close(fds[1]); // 父进程关闭写入端,即父进程进行读取
    while (1)
    {
        sleep(2); // 父进程不读
        char buffer[1024];
        ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            printf("Get Message : %s | mypid = %d\n", buffer, getpid());
        }
        else if (s == 0) // 写入端关闭,读到文件末尾了
        {
            printf("read: %d\n", s);
            break; // 关闭读取端
        }
    }
    n = waitpid(id, NULL, 0);
    assert(n == id);
    close(fds[0]); // 退出程序前,关闭读取端
    return 0;
}



  • 4. 读取端关闭,写入端直接关闭

关闭读取端后,写入端就没有意义了,因此OS会给写入的进程发送信号,终止该进程。

#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    pid_t id = fork();
    assert(id >= 0);
    if (id == 0) // 子进程
    {
        // 子进程通信,关闭子进程的读取端,即子进程进行写入
        close(fds[0]);
        const char *s = "你好,我是子进程,正在进行通信";
        int cnt = 0;
        while (1)
        {
            cnt++;
            char buffer[1024];
            snprintf(buffer, sizeof buffer, "child -> parent say:%s [%d], [%d]", s, cnt, getpid());
            write(fds[1], buffer, strlen(buffer));
            printf("count: %d\n", cnt);
        }
        close(fds[1]); // 退出子进程前关闭文件写入端
        printf("子进程关闭写入端\n");
        exit(0);
    }
    // 父进程
    close(fds[1]); // 父进程关闭写入端,即父进程进行读取
    while (1)
    {
        sleep(2); // 父进程不读
        char buffer[1024];
        ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            printf("Get Message : %s | mypid = %d\n", buffer, getpid());
        }
        break; // 关闭读取端
    }
    close(fds[0]); // 退出程序前,关闭读取端
    printf("父进程关闭读取端\n");
    n = waitpid(id, NULL, 0);
    assert(n == id);
    return 0;
}




【Linux】进程通信----管道通信(下) https://developer.aliyun.com/article/1565748

目录
打赏
0
0
0
0
28
分享
相关文章
Linux内核中的线程和进程实现详解
了解进程和线程如何工作,可以帮助我们更好地编写程序,充分利用多核CPU,实现并行计算,提高系统的响应速度和计算效能。记住,适当平衡进程和线程的使用,既要拥有独立空间的'兄弟',也需要在'家庭'中分享和并行的成员。对于这个世界,现在,你应该有一个全新的认识。
184 67
获取和理解Linux进程以及其PID的基础知识。
总的来说,理解Linux进程及其PID需要我们明白,进程就如同汽车,负责执行任务,而PID则是独特的车牌号,为我们提供了管理的便利。知道这个,我们就可以更好地理解和操作Linux系统,甚至通过对进程的有效管理,让系统运行得更加顺畅。
77 16
|
2月前
|
对于Linux的进程概念以及进程状态的理解和解析
现在,我们已经了解了Linux进程的基础知识和进程状态的理解了。这就像我们理解了城市中行人的行走和行为模式!希望这个形象的例子能帮助我们更好地理解这个重要的概念,并在实际应用中发挥作用。
72 20
|
1月前
|
Linux进程控制(详细讲解)
进程等待是系统通过调用特定的接口(如waitwaitpid)来实现的。来进行对子进程状态检测与回收的功能。
44 0
Linux2.6内核进程调度队列
本篇文章是Linux进程系列中的最后一篇文章,本来是想放在上一篇文章的结尾的,但是想了想还是单独写一篇文章吧,虽然说这部分内容是比较难的,所有一般来说是简单的提及带过的,但是为了让大家对进程有更深的理解与认识,还是看了一些别人的文章,然后学习了学习,然后对此做了总结,尽可能详细的介绍明白。最后推荐一篇文章Linux的进程优先级 NI 和 PR - 简书。
39 0
|
1月前
|
Linux进程概念-详细版(二)
在Linux进程概念-详细版(一)中我们解释了什么是进程,以及进程的各种状态,已经对进程有了一定的认识,那么这篇文章将会继续补全上篇文章剩余没有说到的,进程优先级,环境变量,程序地址空间,进程地址空间,以及调度队列。
35 0
Linux进程概念-详细版(一)
子进程与父进程代码共享,其子进程直接用父进程的代码,其自己本身无代码,所以子进程无法改动代码,平时所说的修改是修改的数据。为什么要创建子进程:为了让其父子进程执行不同的代码块。子进程的数据相对于父进程是会进行写时拷贝(COW)。
41 0
linux命令—tree
tree是一款强大的Linux命令行工具,用于以树状结构递归展示目录和文件,直观呈现层级关系。支持多种功能,如过滤、排序、权限显示及格式化输出等。安装方法因系统而异常用场景包括:基础用法(显示当前或指定目录结构)、核心参数应用(如层级控制-L、隐藏文件显示-a、完整路径输出-f)以及进阶操作(如磁盘空间分析--du、结合grep过滤内容、生成JSON格式列表-J等)。此外,还可生成网站目录结构图并导出为HTML文件。注意事项:使用Tab键补全路径避免错误;超大目录建议限制遍历层数;脚本中推荐禁用统计信息以优化性能。更多详情可查阅手册mantree。
linux命令—tree
linux命令—cd
`cd` 命令是 Linux/Unix 系统中用于切换工作目录的基础命令。支持相对路径与绝对路径,常用选项如 `-L` 和 `-P` 分别处理符号链接的逻辑与物理路径。实际操作中,可通过 `cd ..` 返回上级目录、`cd ~` 回到家目录,或利用 `cd -` 在最近两个目录间快速切换。结合 Tab 补全和 `pwd` 查看当前路径,能显著提升效率。此外,需注意特殊字符路径的正确引用及脚本中绝对路径的优先使用。
|
20天前
|
Linux命令拓展:为cp和mv添加进度显示
好了,就这样,让你的Linux复制体验充满乐趣吧!记住,每一个冷冰冰的命令背后,都有方法让它变得热情起来。
59 8
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等