pipe和pipefd

标签：buffer pipefd pipe 管道进程 close

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和4
    cout<<"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是为了留个空间放\0
        ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlen
        if(n > 0)
        {
            //添加\0，因为要放在buffer数组中读取
            buffer[n]=0;
            cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;
        }
    }
}

运行结果

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