进程间通信(name-pipe C实现）

最新推荐文章于 2024-09-17 09:33:17 发布
最新推荐文章于 2024-09-17 09:33:17 发布
阅读量527 收藏 18
点赞数 18
分类专栏： # 进程间通信 文章标签： c语言 linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41086235/article/details/139984495
版权

背景

进程间大量数据交互，保证其效率高且稳定，风险可控；
- socket：进行大量数据交换时，跟随数据增加，性能越低
- shard memory：内存交换虽然速度最快，但是需要额外增加校验代码，保证数据不会被冲，风险高
- name-pipe: 即使进行大量数据交换，性能低于shard memory，高于socket，且不需要增加额外校验代码，风险低

name-pipe

- 又名FIFO，特殊管道，存放在文件系统中，不会像管道存放在内核中。对命名管道使用结束后，其依旧存在于文件系统中，只有进行删除操作才会消失
- 可以用于进程间通信，不限于同源的两个进程

创建命名管道（FIFO）

  • 命令创建

    • mkfifo [-m mode ] pathname #默认可读可写
    • mknod pathname p

  • 程序创建
    mkfifoat 未研究

    
      #include <sys/types.h>
      #include <sys/stat.h>

      int mkfifo(const char *pathname, mode_t mode);//mode 为0777
      int mknod(char *pathname, mode_t mode, dev_t dev);

      #include <fcntl.h>           /* Definition of AT_* constants */
      #include <sys/stat.h>

      int mkfifoat(int dirfd, const char *pathname, mode_t mode);

能力描述

  • 没有字节流概念（需要注意读取的起始位置是否符合需求）
  • 设备上PIPE可使用的内存大小查询

  # ls -l /proc/sys/fs/ | grep pipe
    -rw-r--r--    1 root     root             0 Nov 24 17:08 pipe-max-size
    -rw-r--r--    1 root     root             0 Nov 24 17:08 pipe-user-pages-hard
    -rw-r--r--    1 root     root             0 Nov 24 17:08 pipe-user-pages-soft

  • 管道长度获取和设置

    
//管道长度可通过fcntl来查询
fcntl(fifo_fd, F_GETPIPE_SZ); //查询
F_SETPIPE_SZ //设置

  • 管道相关问题及解决

    • 读取失败：EAGAIN
      无需处理，等待下一次数据
    • 写失败：EPIPE
      EPIPE表示读取端已经断开，写入端忽略EPIPE错误，同时需要处理SIGPIPE信号量（忽略），不然进程退出
    • 类似POLL方式，写端FD关闭，会提示POLLHUP
      读端重新打开该FD
    • 写端断开，不需要重新打开，等待读端重新连接即可

  • 其它

    • SIGPIPE 也会由socket send产生，可以设置SO_NoSIGPIPE（BSD）或者MSG_NOSIGNAL（Linux）清除
    • SIGPIPE 抑制可以将FIFO设置为O_RDWR，但是这个不能用于进程间通讯，只能人工忽略处理SIGPIPE信号量
    • EPIPE 仅由write失败产生
    • 使用pthread_sigmask 处理write失败产生的SIGPIPE

example

  • 创建FIFO * 2，别名FIFO1，FIFO2，两个进程对该FIFOx仅读或者写
    //进程1
  • 非阻塞只读打开FIFO1
    open(FIFO1, O_RDONLY | O_NONBLOCK);
  • 收到连接标志，只写打开FIFO2;
    open(FIFO1, O_WRONLY | O_NONBLOCK);
    //进程2
  • 非阻塞只写打开FIFO1，只读打开FIFO2
    open(FIFO1, O_WRONLY | O_NONBLOCK);
    open(FIFO2, O_RDONLY | O_NONBLOCK);
  • 发送已连接标志，使用write写FIFO1
  • 创建FIFO3来使进程1知晓进程2存活，write方式，失败会产生EPIPE和SIGPIPE信号量

服务端代码


#include <iostream>
#include <cstring>
#include <cassert>
#include <csignal>
#include <sys/stat.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>

#define FIFO_SERVER_PATH "/var/run/fifo-server-to-client"
#define FIFO_CLIENT_PATH "/var/run/fifo-client-to-server"
static const char fifo_req  = 0x24;
static const char fifo_resp = 0x25;
static int running = true;


static int init_signal_handles(void) {
    //不能GDB Server调试，只能在设备上运行该服务，不然SIGPIPE会一直触发, GDB Server 调试失败
    //忽略SIGPIPE。client意外退出，server 有写动作，会触发SIGPIPE
    if (SIG_ERR == signal(SIGPIPE, SIG_IGN)) {
        std::cout << "ignore SIGPIPE failed,errno:" << errno << std::endl;
        return -1;
    }
    return 0;
}

int main() {
    //server_fd:receive message from client
    //client_fd:reply to client message
    int rc, server_fd, client_fd;
    char buf[1024];

    if (init_signal_handles()) {
        return -1;
    }

    // create name pipe(fifo)
    rc = mkfifo(FIFO_SERVER_PATH, 0777);
    if (rc < 0 && errno != EEXIST) {
        std::cout << "create fifo path:" << FIFO_SERVER_PATH << " failed,errno:" << errno << std::endl;
        return -1;
    }

    std::cout << "create fifo path:" << FIFO_SERVER_PATH << std::endl;

    rc = mkfifo(FIFO_CLIENT_PATH, 0777);
    if (rc < 0 && errno != EEXIST) {
        std::cout << "create fifo path:" << FIFO_CLIENT_PATH << " failed,errno:" << errno << std::endl;
        return -1;
    }

    std::cout << "create fifo path:" << FIFO_CLIENT_PATH << std::endl;

    server_fd = ::open(FIFO_SERVER_PATH, O_RDONLY | O_NONBLOCK);
    if (server_fd < 0) {
        std::cout<< "open path:" << FIFO_SERVER_PATH << " failed:errno:" << errno << std::endl;
        return -1;
    }

    std::cout << "open path:" <<  FIFO_SERVER_PATH << " fd:" << server_fd << std::endl;

    rc = fcntl(server_fd, F_GETPIPE_SZ);
    if (rc < 0) {
        std::cout << "get pipe length failed,errno:" << errno << std::endl;
        return -1;
    }

    std::cout << "fifo length:" << rc << std::endl;

    while (true) {

        struct pollfd fd = {
                .fd = server_fd,
                .events = POLLIN,
                .revents = 0,
        };

        rc = ::poll(&fd, 1, -1);
        if (rc < 0) {
            std::cout << "poll failed,errno:" << errno << std::endl;
        } else {

            if (fd.revents & (POLLERR | POLLHUP)) {
                std::cout << "poll error,revent:" << std::showbase << std::hex << fd.revents << " errno:" << errno << std::endl;

                if (fd.revents & POLLHUP) {
                    //client process exit，need reopen server
                    if (server_fd >=  0) {
                        ::close(server_fd);
                    }

                    server_fd = ::open(FIFO_SERVER_PATH, O_RDONLY | O_NONBLOCK);
                    if (server_fd < 0) {
                        std::cout<< "open path:" << FIFO_SERVER_PATH << " failed:errno:" << errno << std::endl;
                        return -1;
                    }

                    std::cout << "open path:" <<  FIFO_SERVER_PATH << " fd:" << server_fd << std::endl;
                }
                continue;
            }

            if (fd.revents & POLLIN) {

                std::memset(buf, 0, 1024);

                rc = ::read(server_fd, buf, 1024);
                if (rc < 0) {
                    std::cout << "read failed,errno:" << errno << std::endl;
                    continue;
                }
                assert(rc == 1);

                if (fifo_req == buf[0]) {
                    if (client_fd >=  0) {
                        ::close(client_fd);
                    }

                    client_fd = ::open(FIFO_CLIENT_PATH, O_WRONLY | O_NONBLOCK);
                    if (client_fd < 0) {
                        std::cout<< "open path:" << FIFO_CLIENT_PATH << " failed:errno:" << errno << std::endl;
                    }

                    std::cout << "open path:" <<  FIFO_CLIENT_PATH << " fd:" << client_fd << std::endl;

                    rc = ::write(client_fd, &fifo_resp, sizeof(char));
                    if (rc < 0 && errno != EPIPE) {
                        std::cout << "write failed,errno:" << errno << std::endl;
                        continue;
                    }
                }
            }

        }
    }

    return 0;
}

客户端代码

#include <iostream>
#include <cstring>
#include <cassert>
#include <sys/stat.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>

#define FIFO_SERVER_PATH "/var/run/fifo-server-to-client"
#define FIFO_CLIENT_PATH "/var/run/fifo-client-to-server"
static const char fifo_req  = 0x24;
static const char fifo_resp = 0x25;

int main() {
    //server_fd:receive message from client
    //client_fd:reply to client message
    int rc, server_fd, client_fd;
    char buf[1024] = {};

    server_fd = ::open(FIFO_SERVER_PATH, O_WRONLY | O_NONBLOCK);
    if (server_fd < 0) {
        std::cout<< "open path:" << FIFO_SERVER_PATH << " failed:errno:" << errno << std::endl;
        return -1;
    }

    std::cout << "open path:" <<  FIFO_SERVER_PATH << " fd:" << server_fd << std::endl;

    client_fd = ::open(FIFO_CLIENT_PATH, O_RDONLY | O_NONBLOCK);
    if (client_fd < 0) {
        std::cout<< "open path:" << FIFO_CLIENT_PATH << " failed:errno:" << errno << std::endl;
        return -1;
    }

    std::cout << "open path:" <<  FIFO_CLIENT_PATH << " fd:" << client_fd << std::endl;

    rc = ::write(server_fd, &fifo_req, sizeof(char));
    if (rc < 0) {
        std::cout << "write failed,errno:" << errno << std::endl;
        return -1;
    }

    struct pollfd fd = {
            .fd = client_fd,
            .events = POLLIN,
            .revents = 0,
    };

    rc = ::poll(&fd, 1, -1);
    if (rc < 0) {
        std::cout << "poll failed,errno:" << errno << std::endl;
        return -1;
    }

    if (fd.revents & (POLLERR | POLLHUP)) {
        std::cout << "poll error,revent:" << std::showbase << std::hex << fd.revents << "errno:" << errno << std::endl;
        return -1;
    }

    if (fd.revents & POLLIN) {
        rc = ::read(client_fd, buf, 1024);
        if (rc < 0) {
            std::cout << "read failed,errno:" << errno << std::endl;
            return -1;
        }

        assert(rc == 1);

        if (fifo_resp == buf[0]) {
            std::cout << "test success" << std::endl;
        } else {
            std::cout << "test failed,read val:" << buf[0] << std::endl;
        }
    }
    return 0;
}

参考

mkfifo_1
mkfifo_3
fctnl
fifo
重要

1
2

咸鱼的躺平-ZZ
关注
专栏目录
进程间通信---pipe
m0_50488845的博客
04-22 638
进程间通信---pipe管道和socket通信 使用pipe和socket建立一个BBS
Linux进程间通信，IPC-PIPE管道
m0_69190774的博客
03-08 140
管道是IPC通信中的一种最基本的通信机制，所有UNIX系统都提供此种通信机制。
Linux系统编程-进程间通信-1 pipe、FIFO、mmap
m0_74068116的博客
06-29 272
进程间通信（IPC）。Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中是看不到的，所以进程和进程之间不能相互访问，要交换数据必须通过内核。进程间通信的方法：管道（使用最简单）信号（开销最小）共享映射区（无血缘关系）本地套接字（最稳定）
进程间通信 - 管道
酒红的专栏
04-16 1086
介绍进程间的通信方式之一——管道，其原理及适用点，以及相应的C代码实现示例。
【Linux进程间通信】二、pipe管道
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
06-24 3134
Linux进程间通信方式之管道pipe，更多Linux文章请关注专栏《Linux从小白到大神》。
C语言实现进程间通信
zhangts318的博客
04-11 9001
在linux系统中的进程间通信方式有7种。原始的通信方式：无名管道 有名管道 信号， system V的系统上引入如下三种方式：​消息队列 共享内存 信号灯， 通过套接字进行本地进程间通信：BSD​
C语言：进程间通信
m0_58233509的博客
07-17 1118
又内核提供，单工，自同步机制。使用广泛。(管道必须凑齐读写双方才能够运行。
Linux 进程间通信 ---- 命名管道(FIFO文件/name pipe)
huangan_xixi的博客
07-21 931
命名管道出现的背景： 命名管道（FIFO文件/name pipe），之前提到的管道，虽然能够实现进程间的通信，但是局限性也很明显。首先，这个管道只能在具有血缘关系的进程之间通信；第二，他只能实现一个进程写，一个进程读，而如果需要两者同时进行时，就得重新打开一个管道。 为了使任意两个进程之间能够通信，就提出了命名管道 命名管道的特点： 1、与管道的区别：提供了一个路径名与...
python进程间通信---队列和管道
auspark的专栏
04-23 895
python进程间通信---队列和管道（multiprocess.Queue、multiprocess.Pipe） 　　进程间通信：IPC（inter-Process Communication） 1、队列 概念介绍： 　　创建共享的进程队列，Queue是多进程的安全的队列，可以使用Queue实现多进程之间的数据传递。 # Queue([maxsize]) 创建共享的进程队列。 参...
进程间通信之管道pipe与fifo
qq_43460315的博客
03-19 1079
管道pipe()和fifo()的创建和使用
windows-pipe-进程间通信1
Krishna Lee的博客
01-29 4478
稍微研究了一下windows各种进程通信，要求复杂度小、高效率的、双向的、不跨计算机的（不涉及网络的），只专注本地进程通信，总结出2种方式： 第一种：windows named pipe windows pipe可以实现双向通信，一个pipe就能实现，如果涉及阻塞、同步异步、锁…这带来了复杂度提升，因此觉得一个pipe只要专注单向传输就好了，如果要涉及双向传输，使用2个pipe。以下是一种单向传
进程间通信---无名管道、有名管道、信号通信、共享内存、消息队列、信号灯、socket
gg1527672814的博客
12-02 832
进程间通信---无名管道、有名管道、信号通信、共享内存、消息队列、信号灯、socket
LeetCode //C - 365. Water and Jug Problem
Made in Code
09-13 977
【代码】LeetCode //C - 365. Water and Jug Problem。
【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】005 - Kernel 入口 C 函数 start_kernel() 源码分析
|~~~热爱生活、努力学习的小伙汁~~~|
09-15 644
【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】005 - Kernel 入口 C 函数 start_kernel() 源码分析
C语言-第十章：预处理
2303_78095330的博客
09-13 1149
预处理是对代码进行的一些修改，从代码变成可执行程序，就先需要经过预处理。之前出现的 #define、注释都与预处理有关。进行预处理时，会将 define 定义的符号替换成预设的符号，注释会被删除。__FILE__它所在的文件路径__LINE__它所在的行号__DATE__处理它时的日期__TIME__处理它时的时间它所在的函数名int main()printf("文件路径:%s\n",__FILE__);printf("当前行号:%d\n",__LINE__);
CCF刷题计划——田地丈量
Caspiannn的博客
09-12 187
因为是左下，所以相对而言是要挑最小的，可以画图，简单看出，最大是x1,y1。同理，右上角也是，最大最大是（a,b），所以 rx<=a，ry<=b。不妨先按上述方法试试，试了之后就爽了，因为发现如果不存在，这两个点会在同一水平线上，所以rx=lx，计算出来的面积=0，我们可以不用分类，直接用上述方法。我想过用点作为分类的条件，那么情况只有三个，一个点在矩形内部，还有两个点在矩形内部，四个点都在。也不是，如果划的矩形超级大，那么重合的面积就是a*b，但是如果按照我之前的思路的话，就是没有交集。
ESP32工程添加.c .h文件及常见错误
最新发布
woleigequ_ooi的博客
09-17 288
esp32 添加.c.h常见问题整理
什么是进程间通信？有哪些方式可以实现进程间通信？
12-02
以下是一个使用共享内存实现进程间通信的Python代码示例： ```python import multiprocessing def producer(ns, event): ns.value = 'Hello, world!' event.set() def consumer(ns, event): try: event.wait...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值