当前位置：首页 > news >正文

pipe和pipefd

news 2025/7/12 9:45:41

Linux 中 pipe 的详细介绍

在 Linux 中，pipe 是一个系统调用，用于创建一个管道，这是一种用于进程间通信（IPC）的机制。管道允许两个进程之间进行单向数据传输，通常是一个进程向管道写入数据，而另一个进程从管道读取数据。

管道的工作原理

当 pipe 调用成功时，它会返回两个文件描述符，分别对应管道的两端：pipefd[0] 和 pipefd[1]。

pipefd[0] 通常用于读取数据。
pipefd[1] 通常用于写入数据。

数据从 pipefd[1] 写入后，会存储在内核缓冲区中，直到被 pipefd[0] 的读取操作读取。

创建管道

使用 pipe 系统调用来创建管道：

#include <unistd.h>int pipe(int pipefd[2]);

如果 pipe 调用成功，它将返回 0；如果失败，则返回 -1，并且 errno 将被设置以指示错误。

管道的用法

以下是一个简单的例子，展示了如何使用 pipe：

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>int main() {int pipefd[2];pid_t cpid;// 创建管道if (pipe(pipefd) == -1) {perror("pipe");return 1;}// 创建子进程cpid = fork();if (cpid == -1) {perror("fork");close(pipefd[0]);close(pipefd[1]);return 1;}if (cpid == 0) { // 子进程// 关闭不需要的文件描述符close(pipefd[1]);// 读取管道中的数据char message[20];read(pipefd[0], message, sizeof(message) - 1);printf("Received: %s\n", message);close(pipefd[0]);return 0;} else { // 父进程// 关闭不需要的文件描述符close(pipefd[0]);// 写入数据到管道const char *message = "Hello, this is the parent!";write(pipefd[1], message, strlen(message));close(pipefd[1]);// 等待子进程结束wait(NULL);return 0;}
}

pipefd 的介绍

pipefd 是一个整数数组，它包含两个元素，用于存储管道的两个文件描述符。在创建管道后，pipefd[0] 和 pipefd[1] 分别被赋予管道的读取和写入端。

pipefd[0]：管道的读取端，通常用于从管道中读取数据。
pipefd[1]：管道的写入端，通常用于向管道中写入数据。

在上述例子中，pipefd 被用作参数传递给 pipe 函数，并在子进程中用于读取数据，在父进程中用于写入数据。

注意事项

当一个进程关闭管道的任一端时，另一个进程会收到一个 SIGPIPE 信号，除非它已经设置了 SIG_IGN 或 SIG_ERR 处理程序。
管道是单向的，如果你需要双向通信，需要创建两个管道。
管道是阻塞的，这意味着如果管道的另一端没有准备好读取或写入，操作会阻塞直到条件满足。

总结

pipe 是 Linux 中实现进程间通信的一种简单而有效的方法。通过 pipefd，可以访问管道的两个端点，从而实现数据的双向传输。正确使用 pipe 和 pipefd 可以帮助开发者实现高效的进程间通信。

自己总结

pipe创建一个管道

pipe的介绍

1完成这件事：

看图分析

运行结果

#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{//创建管道//先创建一个pipefd数组int pipefd[2];//用n接受一下，判断是否成功int n = pipe(pipefd);if(n<0) return 1;//创建失败了//创建成功//测试一下文件描述符是3和4cout<<"pipefd[0]:"<<pipefd[0]<<"pipefd[1]:"<<pipefd[1]<<endl;return 0;
}

2完成这件事：

创建一个子进程

 pid_t id = fork();if(id < 0)return 2;//创建失败if(id == 0)//创建成功{//子进程}//父进程

让子进程写入，父进程读取

要想让子进程进程写，就需要在进程中关闭读端

if(id == 0)//创建成功
{//子进程close(pipefd[0]);
}

同理

//父进程
close(pipefd[1]);

都用完结束后，可以都关掉

    if(id == 0)//创建成功{//子进程close(pipefd[0]);//.....close(pipefd[1]);}//父进程close(pipefd[1]);//.....close(pipefd[0]);

IPC code，写通信代码

3这件事也完成了：

结构就有了

然后在pipefd[1]这个管道里写，定义一个Writer函数

    if(id == 0)//创建成功{//子进程close(pipefd[0]);//.....IPC code，写通信代码//在pipefd[1]这个管道里写Writer(pipefd[1]);close(pipefd[1]);exit(0);//正常退出}

同理父进程的

    //父进程close(pipefd[1]);//.....IPC code，写通信代码//在pipefd[0]这个管道里写Reader(pipefd[0]);close(pipefd[0]);

//子进程
void Writer(int wfd)
{}
//父进程
void Reader(int rfd)
{}

Writer

//子进程
void Writer(int wfd)
{string s = "hello,I am child";pid_t self = getpid();int number = 0;char buffer[10];while(true){buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了}
}

用到snprintf
介绍

将s和self和number放进buffer

  char buffer[100];while(true){buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了snprintf(buffer,sizeof(buffer),"%s    pid:%d\n",s.c_str(),self);cout<< buffer <<endl;sleep(1);};

用cout打印测试一下，打印成功说明写入buffer成功了

等待进程少不了，子进程exit后需要回收

 //父进程close(pipefd[1]);//.....IPC code，写通信代码//在pipefd[0]这个管道里写Reader(pipefd[0]);//等待进程缺少不了pid_t rid = waitpid(id,nullptr,0);if(rid < 0) return 3;//等待失败了close(pipefd[0]);

如何把消息发送/写入给父进程

用到了write

用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道

//子进程
void Writer(int wfd)
{string s = "hello,I am child";pid_t self = getpid();int number = 0;char buffer[100];while(true){buffer[0] = 0;//字符串清空，只是为了提醒阅读代码的人，我把这个数组当字符串了snprintf(buffer,sizeof(buffer),"%s    pid:%d  %d\n",s.c_str(),self,number++);//用write写入管道（管道也是文件），用strlen，不用+1，不用管\0，因为C语言规定\0结尾，和文件没有关系，wfd写入管道write(wfd,buffer,strlen(buffer));//cout<< buffer <<endl;sleep(1);};
}

父进程该怎么读取呢

用到了read，fd是文件描述符，从特定的文件描述符里读取，放在这个buf里，buf的长度是count

这里就需要考虑到\0，因为buffer中需要\0

//父进程
void Reader(int rfd)
{char buffer[100];while(true){buffer[0] = 0;//用sizeof是为了留个空间放\0ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlenif(n > 0){//添加\0，因为要放在buffer数组中读取buffer[n]=0;cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;}}
}

运行结果

也会发现：为什么子进程sleep，父进程不sleep，父进程还是会跟着子进程sleep，因为父子进程是要协同的