【进程间通信-有名管道_Linux】

于 2022-03-15 17:51:14 发布
阅读量200 收藏
点赞数
分类专栏： Linux 文章标签： linux unix 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sugar_wolf/article/details/123508219
版权

01 / 有名管道

◼ 匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道（FIFO），也叫命名管道、FIFO文件。

◼ 有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。

◼ 一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/O系统调用了（如read()、write()和close()）。与管道一样，FIFO 也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO 的名称也由此而来：先入先出。

◼ 有名管道（FIFO)和匿名管道（pipe）有一些特点是相同的，不一样的地方在于：

  1. FIFO 在文件系统中作为一个特殊文件存在，但 FIFO 中的内容却存放在内存中。

  2. 当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。

  3. FIFO 有名字，不相关的进程可以通过打开有名管道进行通信。

 创建fifo文件
 1.通过命令： mkfifo 名字
 2.通过函数：int mkfifo(const char *pathname, mode_t mode);

 #include <sys/types.h>
 #include <sys/stat.h>
 int mkfifo(const char *pathname, mode_t mode);
     参数：
         - pathname: 管道名称的路径
         - mode: 文件的权限 和 open 的 mode 是一样的
                 是一个八进制的数
     返回值：成功返回0，失败返回-1，并设置错误号

示例

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
    // 判断文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        printf("管道不存在，创建管道\n");        
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       
    }
    return 0;
}
01.1 / 有名管道案例_向管道中写数据

write.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

int main() {

    // 1.判断文件是否存在
    int ret = access("test", F_OK);
    if(ret == -1) {
        printf("管道不存在，创建管道\n");       
        // 2.创建管道文件
        ret = mkfifo("test", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       
    }

    // 3.以只写的方式打开管道
    int fd = open("test", O_WRONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }
    // 写数据
    for(int i = 0; i < 100; i++) {
        char buf[1024];
        sprintf(buf, "hello, %d\n", i);
        printf("write data : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }
    close(fd);
    return 0;
}

read.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

// 从管道中读取数据
int main() {
    // 1.打开管道文件
    int fd = open("test", O_RDONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }
    // 读数据
    while(1) {
        char buf[1024] = {0};
        int len = read(fd, buf, sizeof(buf));
        if(len == 0) {
            printf("写端断开连接了...\n");
            break;
        }
        printf("recv buf : %s\n", buf);
    }
    close(fd);
    return 0;
}
01.2 / 有名管道的注意事项：
    1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
    2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道

读管道：
    管道中有数据，read返回实际读到的字节数
    管道中无数据：
        管道写端被全部关闭，read返回0，（相当于读到文件末尾）
        写端没有全部被关闭，read阻塞等待

写管道：
    管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
    管道读端没有全部关闭：
        管道已经满了，write会阻塞
        管道没有满，write将数据写入，并返回实际写入的字节数。
02 / 有名管道的使用

◼ 通过命令创建有名管道

mkfifo 名字

◼ 通过函数创建有名管道

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

◼ 一旦使用 mkfifo 创建了一个 FIFO，就可以使用 open 打开它，常见的文件

I/O 函数都可用于 fifo。如：close、read、write、unlink 等。

◼ FIFO 严格遵循先进先出（First in First out），对管道及 FIFO 的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如 lseek() 等文件定位操作。

02.1 / 使用有名管道完成聊天的功能

图解

在这里插入图片描述

代码

chatA.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

int main(){

    // 1.判断有名管道文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    // 2.以只写的方式打开管道fifo1
    int fdw = open("fifo1", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功,等待写入...\n");

    // 3.以只读的方式打开管道fifo2
    int fdr = open("fifo2", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功,等待读取...\n");

    char buf[128];
    // 4.循环的写读数据
    while(1) {
        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }

        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

chatB.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

int main() {

    // 1.判断有名管道文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    // 2.以只读的方式打开管道fifo1
    int fdr = open("fifo1", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功,等待读取...\n");
    // 3.以只写的方式打开管道fifo2
    int fdw = open("fifo2", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功,等待写入...\n");

    char buf[128];

    // 4.循环的读写数据
    while(1) {
        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);

        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

成果截图
在这里插入图片描述
在这里插入图片描述

02.2 / 上面的只能一发一收，所以咱们用父子进程来将他们包装一下，这样就可以实现简易的聊天功能

chat1.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/wait.h>

int main(){
    // 1.判断有名管道文件是否存在
    int ret = access("chat1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("chat1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("chat2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("chat2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }
    // 2.以只写的方式打开管道chat1
    int fdw = open("chat1", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道chat1成功,等待写入...\n");

    // 3.以只读的方式打开管道chat2
    int fdr = open("chat2", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道chat2成功,等待读取...\n");


    pid_t pid = fork();
    //父进程写chat1
    if(pid > 0){
        char buf[128] = { 0 };
        while(1) {
            memset(buf, 0, 128);
            // 获取标准输入的数据
            fgets(buf, 128, stdin);
            // 写数据
            ret = write(fdw, buf, strlen(buf));
            if(ret == -1) {
                perror("write");
                exit(0);
            } 
        }
        wait(NULL);  
    }
    //子进程，读chat2
    else if(pid == 0){
        char buf[128];
        while (1)
        {
            // 5.读管道数据
            memset(buf, 0, 128);
            ret = read(fdr, buf, 128);
            if(ret <= 0) {
                perror("read");
                break;
            }
            printf("bufB: %s\n", buf);
        }  
    }

    close(fdr);
    close(fdw);

    return 0;
}

chat2.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/wait.h>

int main(){
    // 1.判断有名管道文件是否存在
    int ret = access("chat1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("chat1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("chat2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("chat2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }
    // 2.以只读的方式打开管道chat1
    int fdr = open("chat1", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道chat1成功,等待写入...\n");

    // 3.以只写的方式打开管道chat2
    int fdw = open("chat2", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道chatA2成功,等待读取...\n");

    pid_t pid = fork();
    //父进程读chat1
    if(pid > 0){
        char buf[128];
        while (1)
        {
            // 5.读管道数据
            memset(buf, 0, 128);
            ret = read(fdr, buf, 128);
            if(ret <= 0) {
                perror("read");
                break;
            }
            printf("bufA: %s\n", buf);
        }
        wait(NULL);  
    }
    //子进程写chat2
    else if(pid == 0){
        char buf[128] = { 0 };
        while(1) {
            memset(buf, 0, 128);
            // 获取标准输入的数据
            fgets(buf, 128, stdin);
            // 写数据
            ret = write(fdw, buf, strlen(buf));
            if(ret == -1) {
                perror("write");
                exit(0);
            } 
        }
    }
    close(fdr);
    close(fdw);   
    return 0;
}

成果截图

在这里插入图片描述
在这里插入图片描述

千北@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
进程间通信-有名管道（FIFO）
自然是VicLi
08-20 2158
9.2.1有名管道概念 无名管道是临时的，在完成通信后自动消息，因为文件描述符只能在某个进程中可见，因此被广泛用于具有亲缘关系的进程间通信，采用的方法是先创建管道，再创建进程，使子进程继承父进程创建的管道文件描述符。 有名管道FIFO有效克服了这一问题，它依赖于文件系统，是一个存在的特殊文件，实现不同进程对文件系统下的某个文件访问是非常方便实现的。因此，FIFO可以在同主机任意进程间实现通信。 有名管道和普通文件一样具有磁盘存放路径、文件权限和其他属性；但是，有名管道和普通文件又有区别，有名管道并没有在磁盘
Linux通过匿名管道进行进程间通信
09-15
【Linux匿名管道进程间通信详解】 在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是实现不同进程间数据共享和协调工作的重要手段。本文将深入探讨一种常见的IPC方式——匿名管道，以及如何...
有名管道的使用
m0_45698131的博客
09-08 2871
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
有名管道
weixin_30522183的博客
05-16 94
管道没有名字，它的通信只限定于亲缘关系间的通信，有名管道实现了无亲缘关系间的通信，原理是fifo提供了一个路径名与之关联，让fifo的文件存于系统中，只要知道该文件路径，就可以进行访问。fifo指代（fist in, fist out），即按照先进先出的工作。 fifo 创建 #include <sys/types.h> #include <sys/stat.h...
有名管道的应用
HP的博客
10-07 635
通过创建两个管道可以实现进程间的全双工通信，同样也可以通过创建两个FIFO来实现不同进程间的全双工通信。Server端 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h
Linux环境进程间通信-管道及有名管道.docx
09-26
与普通管道不同，有名管道允许无亲缘关系的进程间通信，因为它在文件系统中有一个名称。创建有名管道使用`mkfifo()`函数，而读写操作与普通文件相同，使用标准的文件I/O函数。有名管道同样遵循读写规则，但因为有...
Linux进程间通信测试程序.zip_linux_linux 程序_linux 网络_linux网络_进程间通信
最新发布
09-24
Linux支持多种进程间通信方式，包括管道（Pipe）、有名管道（FIFO）、信号量（Semaphore）、共享内存（Shared Memory）、消息队列（Message Queue）、套接字（Socket）以及套接字对（Socket Pair）。这些通信方式各...
ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc
09-23
本文将深入探讨标题“ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc”所涉及的知识点，包括Linux下的管道（pipe）、进程以及进程间通信的基本概念、工作原理和应用实例。 首先，让我们理解什么是进程。在Linux...
UNIX网络编程卷2进程间通信读书笔记（三）—有名管道 （1）
edmond999的专栏
07-10 743
二．有名管道       管道应用的一个重大限制是它没有名字，因此，只能用于具有亲缘关系的进程间通信，在有名管道（named pipe或FIFO）提出后，该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过FIFO不相关的进程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千北@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值