【Linux】进程间通信——管道

最新推荐文章于 2024-07-08 22:09:55 发布
最新推荐文章于 2024-07-08 22:09:55 发布
阅读量787 收藏 27
点赞数 21
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62714628/article/details/138946767
版权

文章目录

一、管道是什么？

管道是 Unix 中最古老的进程间通信的形式, 把从一个进程连接到另一个进程的一个数据流称为一个 “管道”.

二、匿名管道

头文件: #include <unistd.h>
函数声明: int pipe(int pipefd[2]);

  • 返回值: 成功调用返回 0, 失败返回 -1, 并且错误码被设置
  • pipefd: 输出型参数, 传入一个文件描述符数组, 调用成功后, 数组存储匿名管道文件的读写端, pipefd[0] 为读端, pipefd[1] 为写端

首先来看一下 pipefd 中存储的值为何:

#include <iostream>
#include <cassert>
#include <unistd.h>
using namespace std;

int main()
{
    int pipefd[2] = {0}; //定义文件描述符数组
    int n = pipe(pipefd); //创建匿名管道
    assert(n == 0); //检查创建是否成功
    // 查看fd
    cout << "pipefd[0]: " << pipefd[0] << endl;
    cout << "pipefd[1]: " << pipefd[1] << endl;
	return 0;
}

运行结果:
在这里插入图片描述
不出所料, 因为每个进程默认打开 0, 1, 2 号 fd, 所以顺延往后就是 3, 4 号了, 而 3 号 fd 也就是匿名管道的读端, 通过访问 3 号 fd 可以从匿名管道中读取数据, 4 号 fd 也就是匿名管道的写端, 通过访问 4 号 fd 可以向匿名管道中写入数据.

分四种情况讨论匿名管道:
四种情况的前提都是子进程向匿名管道写入, 父进程从匿名管道读取.

  1. 写的速度大于读的速度
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    int pipefd[2] = {0}; //定义文件描述符数组
    int n = pipe(pipefd); //创建匿名管道
    assert(n == 0); //检查创建是否成功
    
    pid_t pid = fork(); //创建子进程
    //子进程执行
    if (pid == 0)
    {
        close(pipefd[0]); //关闭子进程的读端
        int cnt = 1;
        while (true)
        {
            char buf[1024] = {'\0'};
            snprintf(buf, sizeof(buf), "[%d]I am ChildProcess,my pid is %d", cnt++, getpid());
        	write(pipefd[1], buf, strlen(buf));
        }
        close(pipefd[1]); //执行结束,关闭子进程的写端
        return 0;
    }
    
    close(pipefd[1]); // 关闭父进程的写端
    while(true)
    {
    	sleep(3);
        char buf[1024] = {'\0'};
        read(pipefd[0], buf, sizeof(buf));
        cout << "Show Message: " << buf << endl;
    }
    
    close(pipefd[0]); //执行结束,关闭父进程的读端
    int status = 0;
    waitpid(pid, &status, 0); // 等待子进程退出
    // 正常退出,输出退出码
    if (WIFEXITED(status))
    {
        cout << "Exit code is " << WEXITSTATUS(status) << endl;
    }
    // 异常退出,输出终止信号
    else
    {
        cout << "Termination signal is " << (status & 0x7f) << endl;
    }

	return 0;
}

运行结果:
在这里插入图片描述
在父进程没读取之前, 子进程疯狂的往匿名管道写入数据, 等父进程开始读取时, 会直接把子进程写的都读走, 而如果子进程已经把文件写满了还没有被读取, 那么会处于阻塞, 直到有进程读走数据.

  1. 写的速度小于读的速度
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    int pipefd[2] = {0}; //定义文件描述符数组
    int n = pipe(pipefd); //创建匿名管道
    assert(n == 0); //检查创建是否成功
    
    pid_t pid = fork(); //创建子进程
    //子进程执行
    if (pid == 0)
    {
        close(pipefd[0]); //关闭子进程的读端
        int cnt = 1;
        while (true)
        {
            sleep(100);      
            char buf[1024] = {'\0'};
            snprintf(buf, sizeof(buf), "[%d]I am ChildProcess,my pid is %d", cnt++, getpid());
            write(pipefd[1], buf, strlen(buf));
        }
        close(pipefd[1]); //执行结束,关闭子进程的写端
        return 0;
    }
    
    close(pipefd[1]); // 关闭父进程的写端
    while(true)
    {
    	char buf[1024] = {'\0'};
        read(pipefd[0], buf, sizeof(buf));
        cout << "Show Message: " << buf << endl;
    }
    
    close(pipefd[0]); //执行结束,关闭父进程的读端
    int status = 0;
    waitpid(pid, &status, 0); // 等待子进程退出
    // 正常退出,输出退出码
    if (WIFEXITED(status))
    {
        cout << "Exit code is " << WEXITSTATUS(status) << endl;
    }
    // 异常退出,输出终止信号
    else
    {
        cout << "Termination signal is " << (status & 0x7f) << endl;
    }

	return 0;
}

运行结果:
在这里插入图片描述
如果父进程读的很快, 文件里的数据都被读走了, 而此时子进程写的很慢, 那么在文件中已经没有数据可读的情况下, 父进程会阻塞, 直到有数据可读.

  1. 写端在写入5条数据后关闭,读端一直读
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    int pipefd[2] = {0}; //定义文件描述符数组
    int n = pipe(pipefd); //创建匿名管道
    assert(n == 0); //检查创建是否成功
    
    pid_t pid = fork(); //创建子进程
    //子进程执行
    if (pid == 0)
    {
        close(pipefd[0]); //关闭子进程的读端
        int cnt = 1;
        while (cnt <= 5)
        {    
            sleep(1);
            char buf[1024] = {'\0'};
            snprintf(buf, sizeof(buf), "[%d]I am ChildProcess,my pid is %d", cnt++, getpid());
            write(pipefd[1], buf, strlen(buf));
        }
        close(pipefd[1]); //执行结束,关闭子进程的写端
        return 0;
    }
    
    close(pipefd[1]); // 关闭父进程的写端
    while(true)
    {
    	sleep(1);
        char buf[1024] = {'\0'};
        int n = read(pipefd[0], buf, sizeof(buf));
        if(n == 0)
        {
        	break;
        }
        cout << "[" << cnt++ << "]Show Message: " << buf << endl;
    }
    
    close(pipefd[0]); //执行结束,关闭父进程的读端
    int status = 0;
    waitpid(pid, &status, 0); // 等待子进程退出
    // 正常退出,输出退出码
    if (WIFEXITED(status))
    {
        cout << "Exit code is " << WEXITSTATUS(status) << endl;
    }
    // 异常退出,输出终止信号
    else
    {
        cout << "Termination signal is " << (status & 0x7f) << endl;
    }

	return 0;
}

运行结果:
在这里插入图片描述

如果写端已经关闭, 那么读端会一直读到 0, 可以考虑在读端读到 0 时认为写端已经关闭, 那么读端也没有再继续读取的必要了, 可以直接退出, 把读端也关闭了.

  1. 读端在读取5条数据后关闭,写端一直写
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    int pipefd[2] = {0}; //定义文件描述符数组
    int n = pipe(pipefd); //创建匿名管道
    assert(n == 0); //检查创建是否成功
    
    pid_t pid = fork(); //创建子进程
    //子进程执行
    if (pid == 0)
    {
        close(pipefd[0]); //关闭子进程的读端
        int cnt = 1;
        while (true)
        {    
            sleep(1);
            char buf[1024] = {'\0'};
            snprintf(buf, sizeof(buf), "[%d]I am ChildProcess,my pid is %d", cnt++, getpid());
            write(pipefd[1], buf, strlen(buf));
        }
        close(pipefd[1]); //执行结束,关闭子进程的写端
        return 0;
    }
    
    close(pipefd[1]); // 关闭父进程的写端
    int cnt = 1;
    while(cnt <= 5)
    {
    	sleep(1);
        char buf[1024] = {'\0'};
        read(pipefd[0], buf, sizeof(buf));
        cout << "[" << cnt++ << "]Show Message: " << buf << endl;
    }
    
    close(pipefd[0]); //执行结束,关闭父进程的读端
    int status = 0;
    waitpid(pid, &status, 0); // 等待子进程退出
    // 正常退出,输出退出码
    if (WIFEXITED(status))
    {
        cout << "Exit code is " << WEXITSTATUS(status) << endl;
    }
    // 异常退出,输出终止信号
    else
    {
        cout << "Termination signal is " << (status & 0x7f) << endl;
    }

	return 0;
}

运行结果:
在这里插入图片描述
当读端关闭时, 如果写端还一直在写的话, 系统会向写端的进程发送 13 号信号 SIGPIPE 来终止该进程.

匿名管道的特点:

  • 只能用于具有亲缘关系的进程之间进行通信, 一般一个管道由一个进程创建, 然后该进程调用 fork, 通过子进程继承看到相同的 fd, 以此进行通信
  • 管道是半双工通信的, 数据只能向一个方向流动, 即一方写入, 另一方只能读取, 需要全双工通信时, 需要建立两个管道

三、命名管道

头文件:
#include <sys/types.h>
#include <sys/stat.h>

函数声明: int mkfifo(const char *pathname, mode_t mode);

  • 返回值: 成功调用返回 0, 失败返回 -1, 并且错误码被设置
  • pathname: 命名管道文件
  • mode: 命名管道文件访问权限

示例代码:
测试场景: 两个不相关的进程 server 和 client 想要进行通信, 建立通信条件并且进行通信, 让 server 进程进行写入操作, 然后 client 进行读取操作.
先创建一个两个进程都会包含的头文件:

#pragma once
#include <iostream>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

#define MODE 0666
string path_name = "./fifo";

包含了一些会用到的头文件, 还有方便统一修改的宏.

接着编写 server.cpp:

#include "config.h"

//向client写入数据
int main()
{
    umask(0); //修改权限掩码
    int n = mkfifo(path_name.c_str(), MODE); //创建命名管道
    assert(n == 0);
    int fd = open(path_name.c_str(), O_WRONLY); //以只写的方式打开命名管道
    while(1)
    {
        cout << "Enter: ";
        char buf[1024] = {'\0'};
        cin >> buf;
        int n = write(fd, buf, sizeof(buf));
        if(n == 0)
        {
            continue;
        }
    }  

	unlink(path_name.c_str());
    return 0;
}

client.cpp:

#include "config.h"

int main()
{
    int fd = open(path_name.c_str(), O_RDONLY); //以只读的方式打开命名管道
    while(1)
    {
        char buf[1024] = {'\0'};
        int n = read(fd, buf, sizeof(buf));
        assert(n != -1);
        if(n == 0)
        {
            break;
        }
        cout << "client: " << buf << endl;
    }
    return 0;
}

若两个进程想要互相通信, 那么只需要一个进程来创建命名管道文件即可, 在创建了一个命名管道文件后, 另一个进程只需要打开该命名管道文件即可进行访问, 如上案例就是 server.cpp 创建一个命名管道文件并且以写的方式打开了该文件, 而命名管道文件已经被 server.cpp 创建出来了, 那么 client.cpp 只需要以读的方式打开该文件, 两个进程即可开始通信.

运行结果:
先来看看创建的命名管道文件:
在这里插入图片描述
通信结果:
在这里插入图片描述
在 server 中输入后按回车, 信息即可回显在 client 中, 终止进程 server 后, unlink() 会删除命名管道文件.

d4uu
关注
  • 21
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信——管道通信详解
Serendipity_00的博客
11-26 5441
进程间通信：管道引言进程间通信管道 引言 进程是相互独立的，每个进程都有自己的虚拟地址空间，虚拟地址空间通过页表的映射，映射到自己的物理内存上，互不影响。正因为如此，进程间通信就变得很麻烦，操作系统为了使进程间能够通信，会提供一个介质，让多个进程都能够访问，也就是在内存上开辟一块公共资源，让进程在公共资源上交流。 进程间通信 在Linux系统中，有时候需要多个进程之间相互协作，共同完成某项任务，进程之间或线程之间有时候需要传递信息，有时候需要同步协调彼此工作，则就会出现进程间通信。 信号也是进程间通信的一种
实验一 进程通信——管道和信号实验报告.doc
05-13
【进程间通信：管道通信】 实验还涉及到管道（pipe）通信。通过pipe()函数创建一个单向的数据通道，使得两个进程可以通过这个通道交换信息。在这个例子中，父进程创建两条管道，子进程P1和P2分别向各自的管道写入...
Linux进程间通信——管道通信
m0_60154918的博客
08-10 1768
1.UNIX平台进程通信方式AT&T的贝尔实验室，对Unix早期的进程间通信进行了改进和扩充，形成了“system V IPC”，其通信进程主要局限在单个计算机内BSD(加州大学伯克利分校的伯克利软件发布中心)，跳过了该限制，形成了基于套接字(socket)的进程间通信机制Linux继承了上述所有的通信方式2.常用的进程间通信方式1)传统的进程间通信方式无名管道(pipe)、有名管道(fifo)和信号(signal)2)System V IPC对象。...
Linux之进程间通信——管道
一只小卷毛的博客
06-09 2020
管道是Linux中最古老的进程间通信的方式,本文介绍了进程间通信的相关概念，主要介绍了匿名管道和命名管道。
Linux进程间通信——管道(上)
zcxmjw的博客
06-25 333
首先进程间通信指的是不同进程之间传播或交换信息管道，System V进程间通信，POSIX进程间通信而进程间通信的目的主要有以下几个数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux进程间通信——管道
zhangxu
04-09 414
IPC方法 概念： Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。 进...
linux程序间管道通信,linux进程间通信——管道 详解
weixin_34005394的博客
05-11 701
管道是Linux中很重要的一种通信方式，是把一个程序的输出直接连接到另一个程序的输入。常说的管道多是指无名管道，无名管道只能用于具有亲缘关系的进程之间，这是它与有名管道的最大区别。有名管道叫named pipe或者FIFO(先进先出)，可以用函数mkfifo()创建。Linux管道的实现机制在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，...
Linux进程间通信——管道通信_linux管道通信实验
m0_60147147的博客
05-16 405
pipe()函数用于在内核中创建一个管道，该管道一端用于读取管道中的数据，另一端用于将数据写入管道。在创建一个管道后，会获得一对文件描述符，用于读取和写入，然后将参数数组filedes中的两个值传递给获取到的两个文件描述符，filedes[0]指向管道的读端，filedes[1]指向写端。pipe()函数调用成功，返回值为0；否则返回-1，并且设置了适当的错误返回信息。此函数只是创建了管道，要想从管道中读取数据或者向管道中写入数据，需要使用read()和write()函数来完成。
十一、Linux进程间通信——管道
~宪宪的博客
08-13 383
十一、进程间通信 目录：十一、进程间通信一、1. 一、 1.
linux进程间通信——有名管道
weixin_55886550的博客
04-07 967
无名管道只能在父子进程之间进行通信，有名管道提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，任意两个进程通过 FIFO 都能交换数据。要注意FIFO的内容不在磁盘中，而是在内存中。有名管道的本质是文件，FIFO同样有文件描述符，同样可以使用open/write/read等函数，明白这一点的话的话编程就容易很多了。
Linux进程间通信4——使用命名管道.doc
04-30
Linux进程间通信4——使用命名管道.doc
进程间通信——匿名管道
01-06
总结来说，匿名管道是进程间通信的基础工具，尤其适用于简单的单向通信场景。尽管它的功能有限，但其高效和简洁的特性使其在许多早期的系统设计中占据一席之地。理解并熟练掌握匿名管道的使用，对于深入理解操作系统...
Linux通过匿名管道进行进程间通信
09-15
【Linux匿名管道进程间通信详解】 在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是实现不同进程间数据共享和协调工作的重要手段。本文将深入探讨一种常见的IPC方式——匿名管道，以及如何...
【Linux】进程间通信——匿名管道
最新发布
2201_76024104的博客
07-08 1115
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
建立共享linux第三方软件仓库
Znj1421304181的博客
07-08 200
【代码】建立共享linux第三方软件仓库。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 429
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
Linux 系统安全加固：深入 SELinux 与 AppArmor
weixin_39372311的博客
07-08 845
SELinux 和 AppArmor 是两款强大的 Linux 安全模块，它们可以帮助你加固 Linux 系统安全，防止未经授权的访问和恶意行为。通过学习它们的原理、配置和使用方法，你可以更好地保护 Linux 系统安全，确保其稳定运行。
【Linux系列2】Cmake安装记录
kewaqi618的博客
07-08 1029
主要介绍Cmake的安装方法，及自己安装的过程
第七章进程间通信1
08-04
"第七章进程间通信1" 在操作系统中，进程间通信（Inter-Process Communication, IPC...在后续章节中，还将进一步讨论完全网络兼容的进程间通信机制——套接字（Sockets），这是在网络环境中实现进程间通信的重要工具。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值