匿名管道和命名管道

已于 2022-12-06 23:19:50 修改
阅读量730 收藏 4
点赞数 2
文章标签： linux 运维 c++
于 2022-12-06 17:53:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Slowstep_/article/details/128207484
版权

文章目录

匿名管道与命名管道

匿名管道与命名管道均是进程间通信的方式，属于Linux中比较古老的进程间通信的方式，但是很常用，在命令行上，管道的符号是|,表示可以把一个进程处理之后的数据以管道的形式传递给另一个进程。

[slowstep@localhost day32]$ echo "aaaaa" | wc -l
1

进程间通信的常见方式

  • 管道（匿名管道、命名管道）
  • SystemV标准的通信方式，包括共享内存，消息队列、信号量。SystemV标准的通信方式主要用于多进程之间的单机通信
  • posix通信。posix通信方式主要用于多线程下的网络通信

进程间通信的基本认识

  • 进程间通信，简称IPC,进程间通信是为了能让多个进程进行协同，由于单个进程没有并发能力，而在有些场景之下又需要进程间协同，实现并发来完成某些任务，例如：传输数据、同步执行流、消息通知等，在这种情景之下，就需要进程之间能够进行通信。
  • 进程间通信不是目的，而是手段
  • 进程是具有独立性的，每一个进程都有系统为它创建的内核数据结构（如进程控制块task_struct,进程地址空间mm_struct,进程的文件描述符表fd_array[],进程的页表）。因为进程的独立性，就注定了进程之间在进行通信的时候不会很容易，要实现进程间通信，首先要让不同的进程能够看到同一份资源，只有这样，才有可能实现通信。

匿名管道

管道通信是一种单向通信的方式，由一方发送数据，一方接收数据，管道通信的原理是让不同进程能够看到内存中的同一份文件。

当一个进程即以读的方式打开一个文件，又以写的方式打开一个文件时，在内核中对应如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mpsQCFKf-1670320108260)(C:\Users\19199\Desktop\c++研发\Linux\匿名管道与命名管道.assets\image-20221206131758450.png)]

一般而言，struct file在磁盘上有与之对应的文件，struct file中含有该文件的inode信息和内核缓冲区信息。

若一个进程以读和写的方式打开一个文件，然后该进程通过fork创建子进程，那么子进程会拷贝一份父进程的文件描述符表，此时父子进程就能看到同一份资源了，在内核中对应如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7NmBi6Nw-1670320108262)(C:\Users\19199\Desktop\c++研发\Linux\匿名管道与命名管道.assets\image-20221206131820101.png)]

可以用如下代码实现：

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include<sys/wait.h>
#include <fcntl.h>
#include <string.h>
using namespace std;
int main()
{
    int fd1 = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666); //以写方式打开
    int fd2 = open("log.txt", O_RDONLY);                           //以读方式打开
    pid_t id = fork();
    if (id == 0)
    {
        //子进程
        //子进程的3号文件描述符对应写端,4号对应读端
        close(3); //子进程关闭写端
        char buffer[1024] = {0};
        while (true)
        {
            //子进程尝试一直读取内容
            ssize_t num = read(4, buffer, sizeof(buffer) - 1);
            if (num != 0)
            {
                buffer[num] = 0;
                printf("子进程的pid是%d,ppid是%d,子进程从log.txt中读取到了内容,是%s\n", getpid(), getppid(), buffer);
            }
        }
        cout << "---------------------" << endl;
        close(4); //子进程关闭4号文件描述符
        exit(0);  //子进程读取完毕退出
    }
    close(4); //父进程关闭读端
    //父进程向log.txt中写入数据
    int cnt = 0;
    int num = 10;
    char message[1024] = {0};
    while (num--)
    {
        snprintf(message, 1024, "%s %d", "父进程发送消息", cnt++);
        write(3, message, strlen(message));
        sleep(1);
    }
    close(3);      //父进程关闭写端
    wait(nullptr); //父进程尝试回收子进程
    //当父子进程都退出时，系统会回收log.txt的struct file内核数据结构
    return 0;
}

不过这种直接使用磁盘上的文件进行进程间通信具有很大的不足：

  1. 没有访问控制，当父进程以较慢的速度进行写入时，子进程不会等待父进程，而是一直从文件的内核缓冲区中读取内容，如果没有读取到内容的话，read函数直接返回0
  2. 当父进程退出以后，子进程依然在进行读取，子进程不会因为写端被关闭就停止读取，不过此时子进程读取不到任何内容，read函数一直返回0.
  3. 父进程在尝试回收子进程的时候，子进程依然会不断的尝试从log.txt的struct file中读取内容，因此，父进程的回收不会成功，而且由于子进程还与log.txt的struct file有关联，系统也无法回收log.txt的内核数据结构资源，可能导致内存泄漏
  4. 直接采用磁盘上的普通文件来进行进程间通信，可能会产生内存泄漏问题。

基于以上原因，操作系统提供了管道文件来专门进行进程间通信，管道文件分为匿名管道和命名管道。

匿名管道在内核中有struct file内核结构，但是在磁盘上没有与之对应的磁盘文件，没有对应的inode，匿名管道是纯内存级的文件，父子进程通过匿名管道进行通信，属于纯内存级的文件操作，不会将数据交互到磁盘，所有通信的中间过程都是在内存中完成的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HSX2Xgqk-1670320108263)(C:\Users\19199\Desktop\c++研发\Linux\匿名管道与命名管道.assets\image-20221206141412268.png)]

创建匿名管道使用系统调用pipe.

pipe

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

参数pipefd[2]:输出型参数，其中pipefd[0]对应读端的fd，pipefd[1]对应写端的fd.

返回值：创建匿名管道成功返回0，失败返回-1，并且errno被设置。

#include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    int pipefd[2] = {0};
    int x = pipe(pipefd); //创建匿名管道,让进程的文件描述符表与匿名管道建立关联
    if (x == -1)
    {
        perror("创建匿名管道失败");
        return 0;
    }
    // pipefd[0]对应读端，pipefd[1]对应写端
    int id = fork(); //创建子进程
    if (id == 0)
    {
        //子进程
        close(pipefd[1]); //子进程关闭写端,保留读端
        char buffer[1024] = {0};
        while (true)
        {
            //子进程持续读取匿名管道中的内容
            ssize_t num = read(pipefd[0], buffer, sizeof(buffer) - 1);
            //1.如果父进程写端速度较慢，那么子进程会被阻塞，read函数不会返回0
            //2.只有当父进程关闭读端而且子进程把匿名管道中的内容全部读取完毕，再次调用read才会返回0
            if (num > 0)
            {
                //子进程通过pipefd[0](读端)读取到了数据
                buffer[num] = 0;
                cout << "子进程从匿名管道中读取到的内容为" << buffer << endl;
            }
            else
            {
                break; //表示已经没有进程会向匿名管道中写入内容了，同时匿名管道中已经没有数据了
            }
        }
        //读取完毕，子进程关闭读端
        close(pipefd[0]);
        exit(0); //退出进程
    }
    //父进程
    close(pipefd[0]); //父进程关闭读端，保留写端
    int count = 0;
    int num = 10;
    char message[1024] = {0};
    while (num--)
    {
        //父进程通过写端持续向匿名管道写入num条内容
        snprintf(message, sizeof(message), "%s %d", "密码", ++count);
        write(pipefd[1], message, strlen(message));
        sleep(1);
    }
    close(pipefd[1]);                  //父进程关闭写端
    int ret = waitpid(id, nullptr, 0); // fork给父进程返回子进程的pid,父进程回收子进程
    if (ret == -1)
    {
        cout << "回收子进程失败" << endl;
    }
    else
    {
        cout << "成功回收子进程,子进程的pid是" << ret << endl;
    }
    return 0;
}

管道的特点

  • 管道常用于具有血缘关系的进程之间进行通信，例如父子进程

  • 管道的本质是内核中的缓冲区，操作系统为用户提供一段内核缓冲区，供用户进程进行通信

  • 管道为进程间协同提供了访问控制

    缺乏访问控制的例子：如显示器，当父子进程同时调用printf向显示器上打印内容时，是没有先后顺序的，这种行为称为缺乏访问控制

    管道具有访问控制的表现（以父子进程为例）：

    1. 通过管道进行通信的父子进程，当父进程的写入速度慢，而子进程的读取速度快时，子进程会被阻塞，等待父进程写入，此时子进程调用read不会进行返回，当父进程写入完毕，子进程由阻塞状态变为运行状态，调用的read函数返回。

      #include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    int pipefd[2] = {0};
    int x = pipe(pipefd); //创建匿名管道,进程的文件描述符表与匿名管道建立关联
    if (x == -1)
    {
        cout << "创建匿名管道失败" << endl;
        return 0;
    }
    // pipefd[0]对应读端，pipefd[1]对应写端
    int id = fork(); //创建子进程
    if (id == 0)
    {
        //子进程
        close(pipefd[1]); //子进程关闭写端
        char buffer[1024] = {0};
        while (true)
        {
            //子进程非常快速的读取
            ssize_t num = read(pipefd[0], buffer, sizeof(buffer) - 1);
            if (num > 0)
            {
                //子进程通过pipefd[0](读端)读取到了数据
                buffer[num] = 0;
                cout << "子进程从匿名管道中读取到的内容为" << buffer << endl;
            }
            else
            {
                break;
            }
        }
        //读取完毕，子进程关闭读端
        close(pipefd[0]);
        exit(0); //退出进程
    }
    //父进程
    close(pipefd[0]); //父进程关闭读端
    int count = 0;
    int num=10;
    char message[1024] = {0};
    while (num--)
    {
        sleep(5);
        //父进程很慢的向管道中写入内容，此时子进程会在调用read的位置阻塞会等父进程向管道中写入内容
        snprintf(message, sizeof(message), "%s %d", "密码", ++count);
        write(pipefd[1], message, strlen(message));
        printf("%d\n", count);
    }
    close(pipefd[1]);                  //父进程关闭写端
    int ret = waitpid(id, nullptr, 0); // fork给父进程返回子进程的pid,父进程回收子进程
    if (ret == -1)
    {
        cout << "回收子进程失败" << endl;
    }
    else
    {
        cout << "成功回收子进程,子进程的pid是" << ret << endl;
    }
    return 0;
}

    2. 当父进程的写入速度快，而子进程的读取速度慢，当父进程把管道写满时，父进程会被阻塞，等待子进程读取管道中的内容，当子进程读取了管道中的内容，管道有空间后，父进程由阻塞态变为运行态，继续向管道中写入内容。

      #include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    int pipefd[2] = {0};
    int x = pipe(pipefd); //创建匿名管道,进程的文件描述符表与匿名管道建立关联
    if (x == -1)
    {
        cout << "创建匿名管道失败" << endl;
        return 0;
    }
    // pipefd[0]对应读端，pipefd[1]对应写端
    int id = fork(); //创建子进程
    if (id == 0)
    {
        //子进程
        close(pipefd[1]); //子进程关闭写端
        char buffer[1024] = {0};
        while (true)
        {
            sleep(10);
            //子进程每隔10s读取一次
            ssize_t num = read(pipefd[0], buffer, sizeof(buffer) - 1);
            //当子进程还没有读取而且管道中的数据已经满了，父进程会等待子进程读取
            if (num > 0)
            {
                //子进程通过pipefd[0](读端)读取到了数据
                buffer[num] = 0;
                cout << "子进程从匿名管道中读取到的内容为" << buffer << endl;
            }
            else
            {
                break;
            }
        }
        //读取完毕，子进程关闭读端
        close(pipefd[0]);
        exit(0); //退出进程
    }
    //父进程
    close(pipefd[0]); //父进程关闭读端
    int count = 0;
    int num=10000;
    char message[1024] = {0};
    while (num--)
    {
        //父进程快速的向管道中写入内容
        snprintf(message, sizeof(message), "%s %d", "密码", ++count);
        write(pipefd[1], message, strlen(message));
        printf("%d\n",count);
    }
    close(pipefd[1]);                  //父进程关闭写端
    int ret = waitpid(id, nullptr, 0); // fork给父进程返回子进程的pid,父进程回收子进程
    if (ret == -1)
    {
        cout << "回收子进程失败" << endl;
    }
    else
    {
        cout << "成功回收子进程,子进程的pid是" << ret << endl;
    }
    return 0;
}

    3. 管道的访问控制可以体现在父子进程的读写是有规律的，而不是乱序的。

  • 当向管道中写入的数据数据量不大于PIPE_BUF的时候，linux保证写入的原子性，当向管道中写入的数据量大于PIPE_BUF时，linux将不在保证写入的原子性。

    原子性指的是一件事情要么做，要么不做，只有2种状态，没有中间状态，在多执行流的情况下，数据出现并发访问时，讨论原子性才是有意义的。

  • 在管道通信时如果关闭写方，那么读方在将管道中的内容全部读取完毕以后就可以退出了，当读写双方都退出以后，就没有进程与匿名管道相关联了，此时匿名管道在内存中的资源就可以被操作系统回收了。

    #include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    int pipefd[2] = {0};
    int x = pipe(pipefd); //创建匿名管道,进程的文件描述符表与匿名管道建立关联
    if (x == -1)
    {
        cout << "创建匿名管道失败" << endl;
        return 0;
    }
    // pipefd[0]对应读端，pipefd[1]对应写端
    int id = fork(); //创建子进程
    if (id == 0)
    {
        //子进程
        close(pipefd[1]); //子进程关闭写端
        char buffer[1024] = {0};
        while (true)
        {
            sleep(5);
            ssize_t num = read(pipefd[0], buffer, sizeof(buffer) - 1);
            if (num > 0)
            {
                //子进程通过pipefd[0](读端)读取到了数据
                buffer[num] = 0;
                cout << "子进程从匿名管道中读取到的内容为" << buffer << endl;
            }
            else
            {
                break; //读端读到结尾了，停止
            }
        }
        //读取完毕，子进程关闭读端
        close(pipefd[0]);
        exit(0); //退出进程
    }
    //父进程
    close(pipefd[0]); //父进程关闭读端
    int count = 0;
    char message[1024] = {0};
    while (true)
    {
        snprintf(message, sizeof(message), "%s %d", "密码", ++count);
        write(pipefd[1], message, strlen(message));
        printf("%d\n", count);
        if (count == 10000)
        {
            close(pipefd[1]); //父进程关闭写端,此时读端读到文件结尾应该停止了
            break;
        }
    }
    int ret = waitpid(id, nullptr, 0); // fork给父进程返回子进程的pid,父进程回收子进程
    if (ret == -1)
    {
        cout << "回收子进程失败" << endl;
    }
    else
    {
        cout << "成功回收子进程,子进程的pid是" << ret << endl;
    }
    return 0;
}

  • 在管道通信时如果关闭读端，而写端依然在向管道中写入内容，那么当写端把管道写满时，由于没有进程来读取管道中的内容，操作系统会给写端进程发送SIGPIPE信号，终止写端进程。

    #include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    int pipefd[2] = {0};
    int x = pipe(pipefd); //创建匿名管道,进程的文件描述符表与匿名管道建立关联
    if (x == -1)
    {
        cout << "创建匿名管道失败" << endl;
        return 0;
    }
    // pipefd[0]对应读端，pipefd[1]对应写端
    int id = fork(); //创建子进程
    if (id == 0)
    {
        //子进程
        close(pipefd[1]); //子进程关闭写端
        close(pipefd[0]); //子进程也关闭读端
        exit(0);          //退出进程
    }
    //父进程
    close(pipefd[0]); //父进程关闭读端
    int count = 0;
    char message[1024] = {0};
    while (true)
    {
        //子进程关闭读端，父进程还持续的向管道中写
        snprintf(message, sizeof(message), "%s %d", "密码", ++count);
        write(pipefd[1], message, strlen(message));
        printf("%d\n", count);
    }
    printf("-------------------------\n"); //这句话不会被打印出来，父进程持续的向管道中写，但是已经没有读端了，当父进程把管道写满，会被操作系统终止
    int ret = waitpid(id, nullptr, 0);     // fork给父进程返回子进程的pid,父进程回收子进程
    if (ret == -1)
    {
        cout << "回收子进程失败" << endl;
    }
    else
    {
        cout << "成功回收子进程,子进程的pid是" << ret << endl;
    }
    return 0;
}

  • 管道是基于文件的，而文件的生命周期是随进程的，一个struct file,只要没有进程与之关联，操作系统就会回收它，因此，管道的生命周期也是随进程的，如果管道不关联任何进程，操作系统就可以回收这个管道的内存资源。

  • 管道提供的是面向流式的通信服务，是面向字节流的通信服务，简单理解就是当写端写的很快，但是读端读的很慢时，读端可以一次从管道中读取大量的内容，读端在管道中一次最多可以读取的数据量是写端多次向管道中写入的数据量的总和。

  • 管道是单向通信的，属于半双工通信的一种特殊情况。半双工：指的是要么在读，要么在写；全双工：即在读，也在写。

使用匿名管道实现实现简单的进程池

进程池：一个父进程可以通过fork创建多个子进程，父进程通过进程间通信可以给多个子进程派发任务，这种多进程协同工作就是进程池。

task.h

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <unistd.h>
#include <functional>
using TaskFunc = std::function<void()>; //定义函数类型
//任务
void readMySQL()
{
    std::cout << "sub process[" << getpid() << " ] 执行访问数据库的任务\n"
              << std::endl;
}
void execuleUrl()
{
    std::cout << "sub process[" << getpid() << " ] 执行url解析\n"
              << std::endl;
}
void cal()
{
    std::cout << "sub process[" << getpid() << " ] 执行加密任务\n"
              << std::endl;
}
void save()
{
    std::cout << "sub process[" << getpid() << " ] 执行数据持久化任务\n"
              << std::endl;
}

processpool.cxx

#include <iostream>
#include <vector>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <time.h>
#include <string>
#include "task.h"
#define CHILDNUM 5
using namespace std;
void SendTask(int fd, int childpid, int tasknum)
{
    //通过写端fd向指定pid的子进程派发指定编号的任务,只需要把任务的编号发送过去即可
    write(fd, &tasknum, sizeof(tasknum));
    printf("父进程已经向pid为%d的子进程发送了任务,任务编号为%d\n", childpid, tasknum);
}
void CreateHashTask(unordered_map<int, TaskFunc> &hashtask)
{
    hashtask[0] = readMySQL;
    hashtask[1] = execuleUrl;
    hashtask[2] = cal;
    hashtask[3] = save;
}
int main()
{
    vector<pair<int, int>> childtable;     //存放子进程的pid和父进程与该子进程进行通信的写端fd
    unordered_map<int, TaskFunc> hashtask; //存放编号与任务的映射
    vector<int> fatherwrite;
    CreateHashTask(hashtask);
    for (int i = 0; i < CHILDNUM; i++)
    {
        //创建5个子进程和5个管道，父进程可以与5个子进程进行通信
        int pipefd[2] = {0};
        int x = pipe(pipefd);
        if (x == -1)
        {
            cout << "创建管道失败" << endl;
            exit(0);
        }
        //创建一个管道成功
        pid_t id = fork();
        if (id == -1)
        {
            cout << "创建子进程失败" << endl;
            exit(0);
        }
        //子进程创建成功
        if (id == 0)
        {
            //子进程关闭写端
            close(pipefd[1]);
            //父进程会把自己的文件描述符表拷贝给子进程，应该关闭父进程拷贝的写端
            for (int i : fatherwrite)
            {
                close(i);
            }
            while (true)
            {
                //子进程一直读取父进程派发的任务并执行
                int tasknum = 0;
                ssize_t ret = read(3, &tasknum, sizeof(tasknum)); //从管道中读取任务的编号
                printf("ret=%d\n", ret);
                if (ret)
                {
                    if (tasknum >= 4)
                    {
                        cout << "父进程给子进程派发了未知任务" << endl;
                    }
                    else
                    {
                        printf("pid为%d的子进程执行了父进程发送的编号为%d的任务\n", getpid(), tasknum);
                        hashtask[tasknum]();
                    }
                }
                else
                {
                    printf("pid为%d的子进程没有收到任务,已经退出\n", getpid());
                    break;
                }
            }
            //这里直接exit即可，因为管道的声明周期是随进程的
            exit(0);
        }
        //只有父进程才会执行到这里
        close(pipefd[0]);                      //父进程关闭读端
        fatherwrite.push_back(pipefd[1]);      //将父进程写端的文件描述符存到表中
        childtable.push_back({pipefd[1], id}); //第一个参数是父进程的写端fd,第二个参数是对应的子进程的pid
    }
    //到这里父进程创建5个子进程成功
    //父进程给子进程派发任务
    srand((unsigned int)time(nullptr));
    int cnt = 10;
    while (cnt--)
    {
        sleep(1);                                                            //父进程每隔1s随机挑选一个子进程并派发任务
        int who = rand() % childtable.size();                                //随机选一个子进程
        SendTask(childtable[who].first, childtable[who].second, rand() % 4); // first表示写端fd,second表示该子进程的pid,最后一个参数是派发几号任务
    }
    //派发任务完毕，父进程关闭写端
    for (const auto &x : childtable)
    {
        close(x.first);
    }
    //父进程回收子进程
    for (const auto &x : childtable)
    {
        int ret = waitpid(x.second, nullptr, 0);
        if (ret == -1)
        {
            cout << "回收该子进程失败" << endl;
        }
        printf("成功回收了pid为%d的子进程\n", ret);
    }
    return 0;
}

在创建多个管道时，内核中对应情况如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5QZUUWXF-1670320108264)(C:\Users\19199\Desktop\c++研发\Linux\匿名管道与命名管道.assets\image-20221206163002924.png)]
因此，可以记录父进程有那些写端文件描述符，然后下一次创建子进程时，由于文件描述符表要进行拷贝，将该子进程拷贝到的父进程的写端文件描述符关闭即可（也可以不处理，因为只有父进程会向管道中写入数据）。

命名管道

匿名管道是纯内存级的文件，主要用于有血缘关系的进程之间进行通信，如果想要2个毫不相关的进程之间进行通信，可以让它们都打开磁盘上的同一个文件，然后以该文件为中介进行通信。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c365491h-1670320108265)(C:\Users\19199\Desktop\c++研发\Linux\匿名管道与命名管道.assets\image-20221206165815221.png)]

但是这种方法是没有提供访问控制的，再者，采用该方法2个进程之间的通信就不再是纯内存级别的通信了，它们之间进行交换的数据可能会被写入到磁盘，进程间进行通信时，一旦数据被加载到了磁盘，势必会影响通信的效率。

因此操作系统提供了这样一种管道文件：它没有文件内容，向该管道文件中进行写入数据时，数据不会被加载到磁盘，这样的管道文件称之为命名管道。

关闭文件的理解

通过close接口关闭文件实际上是减少了计数。

例如现在有进程A和进程B都打开一个文件，内核为该文件创建一个struct file,同时会维护一个计数（该计数是由Linux内核进行维护的），记录有多少个进程与该文件有关联。

下图所示就是有2个进程与该文件有关联，计数为2.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rt1hG31Z-1670320108265)(C:\Users\19199\Desktop\c++研发\Linux\匿名管道与命名管道.assets\image-20221206172857164.png)]

当一个进程close关闭文件，若该进程与文件之间已经没有关联，引用计数-1,当计数减为0时，表示该文件已经没有进程与之关联，操作系统可以回收该文件的内核数据结构(struct file).

一般而言当一个文件关联多个进程时，进程通过close关闭一个文件只是减少了计数，并未“真正”关闭该文件。

创建命名管道

通过命令行创建一个命名管道文件

通过命令行创建命名管道文件使用mkfifo.

[slowstep@localhost day31]$ mkfifo namedpipe
[slowstep@localhost day31]$ ls
namedpipe  pipe  Processpool
[slowstep@localhost day31]$ ll
total 0
prw-rw-r--. 1 slowstep slowstep  0 Dec  5 09:55 namedpipe
drwxrwxr-x. 2 slowstep slowstep 75 Dec  4 00:46 pipe
drwxrwxr-x. 3 slowstep slowstep 25 Dec  4 17:10 Processpool

命名管道的文件类型是p,由于命名管道的作用就是专门用来进行进程间通信的，它是没有文件内容的，因此命名管道无法通过vim或nano等编辑器进行编辑。

如果一个进程向命名管道中进行写入内容，必须要有另外一个进程读取命名管道中的内容，否则写方进程会被阻塞。

[slowstep@localhost day31]$ echo "hello" > namedpipe 

#没有人从命名管道中读取内容，写方进程被阻塞

如果一个进程读取管道中的内容，但没有进程向管道中进行写入，那么读端进程也会被阻塞。

[slowstep@localhost pipetest]$ cat  < a.pipe 

#读端进程被阻塞
通过系统调用接口创建命名管道

man 3 mkfifo

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

pathname:创建的管道文件的路径和名称，实际创建的文件的路径通过进程的工作目录(cwd)与pathname共同决定

mode:创建的管道文件的权限

返回值：mkfifo调用成功返回0，失败返回-1，并且errno被设置。

#include<iostream>
#include<sys/types.h>
#include<sys/stat.h>
using namespace std;
int main(){
    if(mkfifo("mypipe",0666)<0){
        perror("创建管道文件失败");
        exit(1);
    }
    cout<<"创建管道文件成功"<<endl;
    return 0;
}

当只有一方向命名管道中写入数据，没有进程读取数据，写方进程被阻塞

#include<iostream>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<cstring>
using namespace std;
int main(){
    if(mkfifo("mypipe",0666)<0){
        perror("创建管道文件失败");
        exit(1);
    }
    cout<<"创建管道文件成功"<<endl;
    int fd=open("mypipe",O_WRONLY);
    if(fd==-1){
        perror("打开管道文件失败");
        exit(2);
    }
    //打开管道文件成功，向管道文件中写入
    write(fd,"hello world",strlen("hello world"));
    //如果可以走到这里。表示成功向管道文件中写入了数据
    cout<<"成功向管道文件中写入数据!"<<endl;
    return 0;
}

[slowstep@localhost namedpipe]$ ./a.out 
创建管道文件成功

#没有打印出来"成功向管道文件中写入数据",因为没有进程读取管道中的内容，因此，写方进程被阻塞
通过系统调用删除管道文件

unlink

man 3 unlink

#include <unistd.h>
int unlink(const char *path);

参数：要删除的管道文件的路径

返回值：调用成功返回0，失败返回-1，并且errno被设置。

unlink实际上是删除了文件的计数。

2个进程之间通过命名管道进行简单通信

Serve(服务端)

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
using namespace std;
int main()
{
    if (mkfifo("mypipe", 0666) < 0)
    {
        perror("创建管道文件失败");
        exit(1);
    }
    cout << "创建管道文件成功" << endl;
    int fd = open("mypipe", O_WRONLY);
    if (fd == -1)
    {
        perror("打开管道文件失败");
        exit(2);
    }
    //打开管道文件成功，向管道文件中写入
    write(fd, "hello world", strlen("hello world"));
    //如果可以走到这里。表示成功向管道文件中写入了数据
    close(fd);
    cout << "成功向管道文件中写入数据!" << endl;
    unlink("./mypipe");//进程间通过管道通信完成以后，管道文件基本没有意义了，应该删除
    return 0;
}

Client(客户端)

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
using namespace std;
int main()
{
    int fd = open("mypipe", O_RDONLY);
    if (fd == -1)
    {
        perror("打开管道文件失败");
        exit(1);
    }
    char buffer[1024] = {0};
    read(fd, buffer, sizeof(buffer) - 1);
    cout << buffer << endl;
    close(fd);
    return 0;
}

进程之间通过命名管道进行通信，其方法和操作普通文件一样，管道是基于内存文件的ipc通信方案。

Slowstep_
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
匿名管道、命名管道--Linux
qq_63412763的博客
11-11 1724
管道就是文件。这句话才是最关键的，所有关于管道的操作都是围绕文件进行的。管道作为进程间通信方式的一种，算是比较基础的了。这算是我第一次接触进程间的通信方法吧，感觉之前学习的各种知识已经串起来了，继续努力😎！
【Linux】进程间通信方式①——匿名管道与命名管道（附图解与代码实现）
m0_53133879的博客
09-15 326
这时候一段有趣的对话就出现了： 进程1：大哥，我这边管道创建好了，读写的那两个文件描述符我也拿到了，你快来用这个管道啊！ 进程2：老弟呀，大哥我知道你啥都搞好了，但是我这边没有那两个文件描述符来对管道进行读写啊 进程1：那还不简单，大哥你也用pipe函数创建一个管道获取文件描述符呗！ 进程2：老弟呀，我要用pipe函数了，我这不就创建了一个新的管道了嘛，我还是对你创建的那个管道没有读写权限啊 进程1：那咋整啊大哥，老弟我有一大堆话想通过管道跟你说呢 进程2：老弟啊，现在就只有一个办法了！
【Linux 系统】进程间通信（匿名管道 & 命名管道）-- 详解
Elena's Blog
04-19 1854
也可以说是 cat 从管道中把数据读取出来，这就完成了两个进程之间的通信。
[Linux]进程间通信（上篇）——匿名管道（管道原理，实现示例，端口情况探究！！）
bang___bang_的博客
08-07 1883
文末结语，本篇文章主要讲解进程间通信的目的、分类、技术背景必要性、以及对进程间通信的本质理解。并讲解管道之一的匿名管道，着重展现匿名管道的原理、创建，探究四种读写情况并最后进行总结。 匿名管道有一个很大的缺陷，就是必须要有父子关系的进程间进行通信，这是大大的限制了进程间的通信，那没有父子关系的进程如何通信呢？我们下一篇命名管道再讲解！
进程间通信之匿名管道
k5426244的博客
07-15 669
1.进程间为什么要进行通信？进程间通信的是为了协调不同的进程，使之能在一个操作系统里同时运行，并相互传递、交换信息。2.进程间通信的目的包括：数据传输：一个进程需要将它的数据发送给另一个进程;资源共享：多个进程间共享同样的资源;通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事情，比如进程终止时需要通知其父进程；进程间通信（IPC）是一组编程接口，让程序员能够协调不同的进程，使之能在一个操作系统里同时运行，并相互传递、交换信息；
Linux多进程(二)进程通信方式一 管道
最新发布
Lyajpunov的博客
04-24 1467
管道的是进程间通信（IPC - InterProcess Communication）的一种方式，管道的本质其实就是内核中的一块内存(或者叫内核缓冲区)，这块缓冲区中的数据存储在一个环形队列中，因为管道在内核里边，因此我们不能直接对其进行任何操作。
匿名管道与命名管道的使用
05-23
管道分类： 根据进程的相互关系，可以分为：匿名管道与命名管道。 1 匿名管道：管道是父进程和子进程间，或是子进程与子进程间单向的通讯机制，即一个进程发送数据到管道，另外一个进程从管道中读出数据。如果需要...
匿名管道重定向cmd
10-07
总的来说，理解如何在CMD中使用匿名管道和重定向是深入掌握系统级编程和进程间通信的基础，对于新手来说，这是一个很好的学习起点。通过实践，你可以更好地掌握这一技能，并逐步扩展到更复杂的系统设计。
Python进程通信之匿名管道实例讲解
09-22
在Python编程中，进程通信是多进程环境下...如果需要更复杂的通信，如双向通信，可能需要结合使用多个管道或者选择其他的IPC机制，如命名管道、套接字等。在实际应用中，根据具体需求选择合适的进程通信方式至关重要。
fifo.rar_命名管道
09-24
命名管道与匿名管道类似，都是半双工的（即数据只能单向流动），但它有一个唯一的路径名，使得不相关的进程可以通过这个路径名找到并使用这个管道进行通信。创建命名管道通常使用`mkfifo`系统调用，这会在文件系统中...
linux 匿名管道实例详解
08-30
Linux 匿名管道实例详解 Linux 匿名管道实例详解是 Linux 系统中的一种进程间通信方式。匿名管道是一种半双工通信...但是，对于大规模的系统或应用程序来说，可能需要使用更加复杂的通信方式，如命名管道、Socket 等。
进程间通信 匿名管道 命名管道 pipe namepipe
04-14
VS2008工程 里面有4个工程，命名管道和匿名管道的父子进程。
Linux——进程间通信——命名管道
weixin_69283129的博客
06-28 568
Linux进程间通信——命名管道的详解
进程间通信--匿名管道【Linux】
Mclecak的博客
04-25 239
我们要学的进程间通信，不是告诉我们如何通信，是他们两个如何先看到同一份资源。（文件，内存块...等方式）
进程间通信二 命名管道
仗剑走天涯的博客
07-24 601
前面总结了匿名管道，现在来看命名管道：由于匿名管道的一个限制就是：只能是有血缘关系的进程间才可以通信，比如：有两个同祖先的子进程，父子进程等；为了突破这一个限制，想让没有任何关系的两个进程间也能正常通信，所以就就有了命名管道这样的一个通信机制，一起来看看： 命名管道 一、原理：          管道的一个不足之处是没有名字，因此，只能用于具有亲缘关系的进程间通信，在命名管道（named ...
windows命名管道
热门推荐
草上爬的博客
11-17 1万+
一.windows管道简介 管道（Pipe）的定义： A pipe is a section of shared memory that processes use for communication. The process that creates a pipe is the pipe server. A process that connects to a pipe is a pipe
windows命名管道，匿名管道
sun007700的专栏
04-27 598
https://blog.csdn.net/caoshangpa/article/details/53199022
浅谈Linux管道（pipe）
LittleMagic's Blog
09-22 1271
前言 管道（pipe）是Linux系统中重要的进程间通信（IPC）机制，又分为匿名管道（anonymous pipe）和命名管道（named pipe/FIFO）两种。今天用脑过度，几句话简单谈论一下。 匿名管道 当我们在一般语境下提起管道这个词时，说的就是匿名管道。匿名管道在两个有亲缘关系的进程（即存在父子或兄弟关系的进程）之间创建，本质上是由内核管理的一小块内存缓冲区，默认大小由系统中的PIP...
匿名管道和命名管道（代码剖析）
嘴大且吃雯的博客
11-11 353
管道的特性，匿名管道与命名管道的通信方式，代码实现与总结
匿名管道和命名管道详解
04-05
匿名管道和命名管道都是用于进程间通信的方式，但它们之间有一些区别。 匿名管道： 匿名管道是一种单向通信方式，只能用于父子进程或者兄弟进程之间的通信。在创建匿名管道时，操作系统会自动为其分配一个文件描述符，通过该文件描述符，进程可以进行读写操作。 匿名管道的创建方式如下： ```C int pfd[2]; pipe(pfd); // 创建匿名管道 ``` 其中，pfd[0]是管道的读端，pfd[1]是管道的写端。 匿名管道的使用方式如下： ```C char buf[1024]; pid_t pid; int pfd[2]; pipe(pfd); pid = fork(); if (pid == 0) { // 子进程 close(pfd[1]); // 关闭写端 read(pfd[0], buf, sizeof(buf)); // 读取数据 printf("child process read from pipe: %s\n", buf); close(pfd[0]); // 关闭读端 } else if (pid > 0) { // 父进程 close(pfd[0]); // 关闭读端 write(pfd[1], "hello world", strlen("hello world")); // 写入数据 close(pfd[1]); // 关闭写端 } else { perror("fork"); exit(1); } ``` 命名管道： 命名管道也是一种单向通信方式，但可以用于任意进程之间的通信。在创建命名管道时，需要指定一个路径名，并且需要手动创建该文件。操作系统会为其分配一个文件描述符，通过该文件描述符，进程可以进行读写操作。 命名管道的创建方式如下： ```C int fd; mkfifo("/tmp/myfifo", 0666); // 创建命名管道 fd = open("/tmp/myfifo", O_RDONLY); // 打开命名管道 ``` 其中，"/tmp/myfifo"是文件路径名，0666是文件权限。 命名管道的使用方式如下： ```C char buf[1024]; int fd; fd = open("/tmp/myfifo", O_RDONLY); read(fd, buf, sizeof(buf)); // 读取数据 printf("read from fifo: %s\n", buf); close(fd); ``` 需要注意的是，命名管道的写入操作可以在任意进程中进行，只要有权限打开该文件即可。如果多个进程同时写入数据到同一个命名管道，可能会导致数据混乱。因此，使用命名管道时需要特别注意数据的同步问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值