【Linux系统】命名管道 && 共享内存

最新推荐文章于 2024-08-14 22:57:51 发布
最新推荐文章于 2024-08-14 22:57:51 发布
阅读量939 收藏 20
点赞数 19
分类专栏： 【Linux系统学习】玩转Linux 文章标签： linux 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78611726/article/details/140340039
版权

命名管道

原理

匿名管道是通过父子进程的继承关系来实现通信的，那如果是两个毫不相干的两个进程呢？？？

而命名管道就可以实现，命名管道是通过创建一个管道文件，而这个管道文件由两个进程共同使用，这其实就是通过文件路径让两个进程看到了同一份资源！！！

常用接口

mkfifo --- 创建管道文件

 pathname：路径字符串

mode：权限，一般0666

 unlink --- 删除管道文件

pathname：路径字符串

指令

mkfifo：创建一个指定管道文件

unlink 文件：删除一个指定管道文件

使用

Makefile

.PHONY:all
all:client server

client:client.cc
	@g++ -o $@ $^ -std=c++11
server:server.cc
	@g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -rf client server

NamedPipe.hpp

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

const std::string comm_path = "./NamedPipe";
#define DefaultFd -1
#define Creater 1
#define User 2
#define Read O_RDONLY
#define Write O_WRONLY
#define BaseSize 4096

class NamedPipe
{
private:
    bool OpenNamedPipe(int mode)
    {
        _fd = open(_fifo_path.c_str(), mode);
        if (_fd < 0)
            return false;
        return true;
    }

public:
    NamedPipe(const std::string &fifo_path, int who)
        : _fifo_path(fifo_path), _id(who), _fd(DefaultFd)
    {
        if (_id == Creater)
        {
            int res = mkfifo(_fifo_path.c_str(), 0666);
            if (res != 0)
            {
                perror("mkfifo");
            }
            std::cout << "creater create named pipe" << std::endl;
        }
    }
    bool OpenForRead()
    {
        return OpenNamedPipe(Read);
    }
    bool OpenForWrite()
    {
        return OpenNamedPipe(Write);
    }
    int ReadNamedPipe(std::string *out)
    {
        char buffer[BaseSize];
        int n = read(_fd, buffer, sizeof(buffer));
        if (n > 0)
        {
            buffer[n] = 0;
            *out = buffer;
        }
        return n;
    }
    int WriteNamedPipe(std::string &in)
    {
        return write(_fd, in.c_str(), in.size());
    }
    ~NamedPipe()
    {
        if (_id == Creater)
        {
            int res = unlink(_fifo_path.c_str());
            if (res != 0)
            {
                perror("unlink");
            }
            std::cout << "creater free named pipe" << std::endl;
        }
        if (_fd != DefaultFd)
            close(_fd);
    }

private:
    const std::string _fifo_path;
    int _id;
    int _fd;
};

client.cc

#include"NamedPipe.hpp"

int main()
{
    NamedPipe fifo(comm_path, User);
    if(fifo.OpenForWrite())
    {
        std::cout << "client open named pipe done" << std::endl;
        while(true)
        {
            std::cout << "Please Enter>";
            std::string message;
            std::getline(std::cin, message);
            fifo.WriteNamedPipe(message);
        }
    }
    return 0;
}

server.cc

#include"NamedPipe.hpp"

//server read --- 管理命名管道的整个生命周期
int main()
{
    // 对于读端而言,如果我们打开文件，但是写还没来，我会阻塞在open调用中，直到对方打开
    // 进程同步
    NamedPipe fifo(comm_path, Creater);
    if(fifo.OpenForRead())
    {
        std::cout << "server open named pipe done" << std::endl;
        while(true)
        {
            std::string message;
            int n = fifo.ReadNamedPipe(&message);
            if(n > 0)
            {
                std::cout << "Client Say>" << message << std::endl;
            }
            else if(n == 0)
            {
                std::cout << "Client quit, Server Too!" << std::endl;
                break;
            }
            else
            {
                std::cout << "fifo.ReadNamedPipe Error" << std::endl;
                break;
            }
        }
    }
    return 0;
}

总结

匿名管道是通过父子进程继承关系来看到同一份资源。

命名管道是通过文件路径来看到同一份资源。

共享内存

其实什么匿名管道命名管道，以及接下来的共享内存都是本地通信。

本地通信方案的代码：System V IPC 包括

共享内存

消息队列

信号量

原理

共享内存也就是共享同一份内存！！！如何理解？？？

原理图

 理解：

  1. 所有的刚才的操作都是OS做的。
  2. OS提供上面1、2步骤的系统调用，供用户进程A、B进行调用 --- 系统调用
  3. AB进程可以共享一份内存，还有很多CD、EF...共享内存在系统中可以存在很多份，供不同个数，不同进程同时进行通信！
  4. OS注定了要对共享内存进行管理！--- 先描述，在组织 -- 共享内存，不是简单的一段内存空间，也要有描述并管理共享内存的数据结构和匹配的算法！
  5. 共享内存 = 内存空间（数据） + 共享内存的属性！

常用接口

shmget --- 获取共享内存

功能：用来创建共享内存
原型：
int shmget(key_t key, size_t size, int shmflg);
参数：
key:这个共享内存段名字（用户形成）
size:共享内存大小
shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

shmflag的取值

IPC_CREAT:如果你要创建的共享内存不存在，就创建，若存在，获取该共享内存并返回（总能获得一个标识）

IPC_EXCL:单独使用没有意义，与IPC_CREAT组合才有意义

IPC_CREAT | IPC_EXCL:如果你要创建的共享内存不存在，就创建，若存在，出错返回（如果成功返回了就说明shm是全新的）

shmctl函数

功能：用于控制共享内存
原型
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数
shmid:由shmget返回的共享内存标识码
cmd:将要采取的动作（有三个可取值）
buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值：成功返回0；失败返回-1

cmd的三个可取值

IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值。

IPC_SET：在进程有足够权利的情况下，把共享内存当前的关联值设置为shmid_ds数据结构中给出的值。

IPC_RMID：删除共享内存段。

ftok --- 可以为我们形成一个随机的key来标识我们的共享内存。

 我（进程）怎么知道，OS的共享内存是否存在呢？--- 唯一性标识符

key vs shmid

key:属于用户形成，内核使用的一个字段，用户不能使用key来进行shm的管理，内核进行区分shm的唯一性的。（struct file*）

 shmid：内核给用户返回的一个标识符，用来进行用户级对共享内存进行管理的id值（fd）

 shmat

功能：将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数
shmid: 共享内存标识
shmaddr:指定连接的地址
shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1

返回共享内存的起始地址，我们可以让其与malloc返回值类比，都是void*的返回。

shmdt

功能：将共享内存段与当前进程脱离
原型
int shmdt(const void *shmaddr);
参数
shmaddr: 由shmat所返回的指针
返回值：成功返回0；失败返回-1
注意：将共享内存段与当前进程脱离不等于删除共享内存段
 

指令

ipcs -m 查看当前所有的共享内存具体信息

 共享内存是OS级的，进程结束不会随进程释放！！！--- 一直存在，直到系统重启

所以只能手动释放（指令或者其他系统调用）  --- 生命周期随内核 ，文件生命周期随进程

我们可以使用命令ipcs -m来查看共享内存

ipcrm -m --- 删除指定共享内存

使用

shm.hpp

#ifndef __SHM__HPP__
#define __SHM_HPP__

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

const int gCreater = 1;
const int gUser = 2;
const int gShmSize = 4096;
const std::string gpathname = "/root/2024_code/shm";
const int gproj_id = 0x66;

class Shm
{
private:
    key_t GetCommKey()
    {
        key_t k = ftok(_pathname.c_str(), _proj_id);
        if (k < 0)
        {
            perror("ftok");
        }
        return k;
    }
    int GetShmHelper(key_t key, int size, int flag)
    {
        int shmid = shmget(key, size, flag);
        if (shmid < 0)
        {
            perror("shmget");
        }
        return shmid;
    }
    void *AttachShm()
    {
        if (_addrshm != nullptr)
            DetachShm(_addrshm);
        void *shmaddr = shmat(_shmid, nullptr, 0);
        if (shmaddr == nullptr)
        {
            perror("shmat");
        }
        std::cout << "who:" << RoleToString(_who) << " attach shm..." << std::endl;
        return shmaddr;
    }
    std::string RoleToString(int who)
    {
        if (who == gCreater)
            return "gCreater";
        else if (who == gUser)
            return "gUser";
        else
            return "None";
    }
    void DetachShm(void *shmaddr)
    {
        if (shmaddr == nullptr)
            return;
        shmdt(shmaddr);
        std::cout << "who:" << RoleToString(_who) << " detach shm..." << std::endl;
    }

public:
    Shm(const std::string &path, int proj_id, int who)
        : _pathname(path), _proj_id(proj_id), _who(who), _addrshm(nullptr)
    {
        _key = GetCommKey();
        if (_who == gCreater)
            GetShmForCreate();
        else if (_who == gUser)
            GetShmForUser();
        _addrshm = AttachShm();
        std::cout << "shmid:" << _shmid << std::endl;
        std::cout << "key:" << ToHex(_key) << std::endl;
    }
    ~Shm()
    {
        if (_who == gCreater)
        {
            int res = shmctl(_shmid, IPC_RMID, nullptr);
        }
        std::cout << "shm remove done..." << std::endl;
    }
    std::string ToHex(key_t key)
    {
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "0x%x", key);
        return buffer;
    }
    bool GetShmForCreate()
    {
        if (_who == gCreater)
        {
            _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | IPC_EXCL | 0666);
            std::cout << "shm create done..." << std::endl;

            if (_shmid >= 0)
                return true;
        }
        return false;
    }
    bool GetShmForUser()
    {
        if (_who == gUser)
        {
            _shmid = GetShmHelper(_key, gShmSize, IPC_CREAT | 0666);
            std::cout << "shm get done..." << std::endl;

            if (_shmid >= 0)
                return true;
        }
        return false;
    }
    void Zero()
    {
        if (_addrshm)
        {
            memset(_addrshm, 0, gShmSize);
        }
    }
    void *Addr()
    {
        return _addrshm;
    }

private:
    key_t _key;
    int _shmid;

    std::string _pathname;
    int _proj_id;

    int _who;
    void *_addrshm;
};

#endif

server.cc

#include"shm.hpp"
#include"NamedPipe.hpp"

int main()
{
    //1.创建共享内存
    Shm shm(gpathname, gproj_id, gCreater);
    char* shmaddr = (char*)shm.Addr();

    //2.创建管道
    NamedPipe fifo(comm_path, Creater);
    fifo.OpenForRead();

    while(true)
    {
        std::string temp;
        fifo.ReadNamedPipe(&temp);
        std::cout << "shm memory content:" << shmaddr << std::endl;
    }
    sleep(5);
    return 0;
}

client.cc

#include"shm.hpp"
#include"NamedPipe.hpp"

int main()
{
    //创建共享内存
    Shm shm(gpathname, gproj_id, gUser);
    shm.Zero();
    char* shmaddr = (char*)shm.Addr();

    //2.打开管道
    NamedPipe fifo(comm_path, User);
    fifo.OpenForWrite();

    //当成string
    char ch = 'A';
    while(ch <= 'Z')
    {
        shmaddr[ch - 'A'] = ch;
        
        std::string temp = "wakeup";
        std::cout << "add " << ch << " into Shm, " << "wakeup reader" << std::endl;
        fifo.WriteNamedPipe(temp);

        sleep(2);
        ch++;
    }
    sleep(5);
    return 0;
}

总结

缺点：共享内存不提供对共享内存的任何保护机制 --- 数据不一致问题

优点：我们在访问共享内存的时候，没有使用任何系统调用，共享内存是所有进程间通信IPC，速度最快的，因为，共享内存大大减少了数据的拷贝次数！！！

花影随风_
关注
专栏目录
【Linux学习】第七弹：进程间通信——管道、共享内存、消息队列
百万计划的小小博客
06-09 705
本文主要介绍了LInux操作系统中进程间通信的常用方式：管道、共享内存、消息队列等，详细介绍其定义与使用方式。
【Linux】进程间通信（无名/有名管道及System V共享内存）
学了就忘是正常现象
02-25 1255
无名管道+有名管道+System V共享内存。
进程通信——管道与共享内存
qq_61932634的博客
05-05 484
对于不同的进程，进行进程通信有很多的目的，但总体来说，有以下这些目的：：一个进程需要将它的数据发送给另一个进程：多个进程之间共享同样的资源。：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种（如 进程终止时要通知父进程）。：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希 望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。而接下主要介绍两种通信方式，管道和共享内存，至于消息队列、信号量等通信方式，大概会在以后讲解。
进程间通信 ---共享内存
最新发布
BUG制造机的博客
08-14 1181
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
管道和共享内存
qq_33436509的博客
08-22 2469
一，无名管道 特点： 其本质是一个伪文件(实为内核缓冲区) 由两个文件描述符引用，一个表示读端（fd[0]），一个表示写端(fd[1])。 规定数据从管道的写端流入管道，从读端流出。 原理： 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现 局限性： ① 数据自己读不能自己写。 ② 数据一旦被读走，便不在管道中存在，不可反复读取。 ③ 由于管道采用半双工通信方式。因此，数据...
深度剖析管道与共享内存
唐学长的博客
04-15 1143
管道 匿名管道 命名管道 共享内存 共享内存命令
进程间通信--管道通信和共享内存
weixin_58250064的博客
03-19 390
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux系统教学中关于命名管道文件的解析.pdf
09-06
命名管道（Named Pipe）是Linux操作系统中一种进程间通信（IPC，Inter-Process Communication）的方式，它允许不同的进程之间共享数据。与无名管道（Anonymous Pipe）相比，命名管道最大的特点在于它具有名字，可以...
Linux 管道 管道命令 命名管道
Nick_Di的博客
06-14 635
读了《Unix/Linux系统编程》第三章关于管道部分，根据书上内容与网上资料进行了总结。如果有问题请批评指正！ 1. 管道相关概念 管道是用于进程交换数据的单向进程间通信通道。 管道有一个读取端进程和一个写入端进程，且读取端进程与写入端进程不能是同一个进程。数据只能从写入端写入，读取端读出。且数据一旦被读走遍不在管道中存在，即不可反复读取。 管道不能同时读写，且数据传输方向是单向的。有些系统支持双向管道，数据可以双向传输。 读取端读数据时：如果管道上有数据，读进程根据需要读取管道中的数据并返回
管道(匿名管道, 命名管道)和共享内存
y2zaijian的博客
08-04 938
管道 每个进程都拥有自己的独立的虚拟地址空间和页表结构, 所以每个进程是独立的, 进程间必须借助媒介来进行通信, 这些媒介包括管道, 共享内存 消息队列 和信号量 1. 匿名管道 匿名管道(在内核中创建的这块缓冲区并没有一个标识), 但是内核会返回给我们用户两个文件描述符(fd[0]缓冲区的读端, fd[1]缓冲区的写端), 创建匿名管道的接口 int pipe(int fd[2]) fd[2] : 具有两个元素的整形数组, 包括fd[0], fd[1], 接口返回值
【Linux操作系统】--进程间通信--匿名管道和命名管道
qq_53413129的博客
05-04 1578
进程间通信介绍 进程间通信目的 进程间通信发展 匿名管道 什么是管道 站在文件描述符角度-深度理解管道 匿名管道 建立信道 开始操作-管道基本特性 总结： 命名管道 命名管道 创建一个命名管道 编写一个命名管道 创建管道 服务器端读取 客户端client写入 写端业务逻辑 拓展功能 总结
linux管道和共享内存的区别,linux 管道、消息队列、共享内存的对比
weixin_42512356的博客
05-01 1483
------管道管道的优点是不需要加锁，缺点是默认缓冲区太小，只有4K，同时只适合父子进程间通信，而且一个管道只适合单向通信，如果要双向通信需要建立两个。而且不适合多个子进程，因为消息会乱，它的发送接收机制是用read/write这种适用流的，缺点是数据本身没有边界，需要应用程序自己解释，而一般消息大多是一个固定长的消息头，和一个变长的消息体，一个子进程从管道read到消息头后，消息体可能被别的子...
管道通信，共享内存
Jonathan的博客
05-16 977
有名管道（Named Pipe）是一种特殊的文件类型，也称为 FIFO。它提供了一种进程间通信的机制，允许不相关的进程通过读写共享的文件来交换数据。与普通文件不同的是，有名管道在文件系统中存在一个路径名，并且可以被多个进程同时打开和使用。它通常用于解决在异步场景下进程间通信的问题，例如一个进程在产生数据，另一个进程需要从该数据中获取信息，但这两个进程的执行速度不同步，无法通过传统的函数调用或消息队列来进行数据交换。有名管道是一种文件类型，因此它可以在文件系统中被访问、创建、删除等操作。
管道、消息队列和共享内存三者的特点与区别
qq_43671531的博客
03-01 4086
管道和消息队列的区别 管道（PIPE） 管道通信方式的中间介质是文件，通常称这种文件为管道文件。两个进程利用管道文件进行通信时，一个进程为写进程，另一个进程为读进程。写进程通过写端（发送端）往管道文件中写入信息；读进程通过读端（接收端）从管道文件中读取信息。两个进程协调不断地进行写、读，便会构成双方通过管道传递信息的流水线。 管道分为匿名管道和命名管道。 （1）匿名管道:管道是半双工的，数据只...
linux管道和共享内存的区别,linux中的pipe和fifo的区别
weixin_36197669的博客
05-01 333
linux中的pipe和fifo的区别在linux进程间通信(IPC)可以通过信号量、文件系统、消息队列、共享内存还有管道来实现的。其中消息队列、内存管理是在SystemV中提出的。进程通信间涉及到了管道，而且管道在shell命令中也大有用处。那就简要说说管道：管道顾名思义，你可以将其理解为日常生活中的管子，一边流入，一边流出。它可以有半双工和全双工。半双工就是只能一边流入，另一边流出；全双工则是...
操作系统实验报告——进程管道消息信号量共享存储区通信实验
m0_56267074的博客
12-22 786
操作系统实验Linux
命名管道 与 共享内存区别，以及两者混用。
你悄悄的来到了我的博客
11-23 2192
共享内存读取和写互相不影响，即使你不写入，读取那边也会不断读取，只是有数据就读取数据，无数据则值保持不变 命名管道：读取时 若无数据写入，则会处于wait状态。 尝试了一个demo，pipe传输数据，再用共享内存传输数据，双线程。因为有可能出现数据读写错误，所以中间的操作需要用原子操作，可以将中间数据设定为一个int值或char等系统自带的数据类型。实现的效果：有数据更新时更新数据，没有数据的...
冰冰学习笔记：管道与共享内存
bingbing_bang的博客
12-29 972
进程间通信，管道，共享内存的使用
内存共享 管道_解决位桶管道内存问题
weixin_26629687的博客
09-17 188
内存共享 管道Since our team is using Bitbucket Pipelines more and more, something we are running into more often, is Bitbucket Pipelines failing with the error Container ‘docker' exceeded memory limit. In t...
Linux操作系统与进程间通信：命名管道与共享内存详解
本文主要介绍了两种进程间通信（IPC）机制：命名管道和共享内存，并提及了嵌入式Linux系统的基础知识。首先，命名管道（Named Pipe）是一种半双工的通信方式，它允许一个进程向管道写入数据，而另一个进程从管道读取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

花影随风_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值