linux进程间通信【共享内存】

于 2024-02-29 11:25:21 发布
阅读量834 收藏 16
点赞数 21
分类专栏： linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45476980/article/details/136358364
版权

目录

准备工作：

正文 

1.什么是共享内存？

2.共享内存

2.1共享内存数据结构

2.2 创建 shmget 

2.2.1关于key的获取

2.3释放共享内存

 2.3.1通过指令释放

2.3.2通过共享内存控制函数释放

2.4进程关联 shmat 

2.5进程去关联 shmdt

2.6共享内存控制 shmctl

 3.共享内存的简单实用

4.共享内存的知识补充

4.1共享内存的大小

4.2共享内存快的原因 

4.3共享内存缺点 

5.共享内存实操-配合命名管道完成通信 

5.1逻辑设计

5.2 代码部分

5.3注意事项 

总结：

准备工作：

共享内存出自 System V 标准，是众多 IPC 解决方案中最快的一种，使用共享内存进行通信时，不需要借助函数进入内核传递数据，而是直接对同一块空间进行数据访问，至于共享内存是如何使用的、通信原理是怎么实现的、以及共享内存+命名管道的组合通信程序该如何实现

正文 

1.什么是共享内存？

共享内存 全称 System V 共享内存，是一种进程间通信解决方案，并且是所有解决方案中最快的一个，在通信速度上可以做到一骑绝尘

这是 System V 标准中一个比较成功的通信方式，特点就是非常快，除此之外，System V 标准中还有另外两种通信方式：

  • 消息队列
  • 信号量

先来看看 System V 共享内存的工作原理：在物理内存中开辟一块公共区域，让两个不同的进程的虚拟地址同时对此空间建立映射关系，此时两个独立的进程能看到同一块空间，可以直接对此空间进行【写入或读取】，这块公共区域就是 共享内存 

显然，共享内存的目的也是 让不同的进程看到同一份资源

关于共享区：共享区作为虚拟地址空间中一块缓冲区域，既可作为堆栈生长扩展的区域，也可用来存储各种进程间的公共资源，比如这里的共享内存，以及之前学习的动态库，相关信息都是存储在共享区中

注意： 共享内存块的创建、进程间建立映射都是由 OS 实际执行的

2.共享内存

2.1共享内存数据结构

共享内存不止用于两个进程间通信，所以共享内存必须确保能持续存在，这也就意味着共享内存的生命周期不随进程，而是随操作系统，一旦共享内存被创建，除非被删除，否则将会一直存在，因此 操作系统需要对共享内存的状态加以描述

共享内存也不止存在一份，当出现多块共享内存时，操作系统不可能一一比对进行使用，秉持着高效的原则，操作系统会把已经创建的共享内存组织起来，更好的进行管理

 注：shm 表示共享内存

 

struct shmid_ds
{
    struct ipc_perm shm_perm;    /* operation perms */
    int shm_segsz;               /* size of segment (bytes) */
    __kernel_time_t shm_atime;   /* last attach time */
    __kernel_time_t shm_dtime;   /* last detach time */
    __kernel_time_t shm_ctime;   /* last change time */
    __kernel_ipc_pid_t shm_cpid; /* pid of creator */
    __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
    unsigned short shm_nattch;   /* no. of current attaches */
    unsigned short shm_unused;   /* compatibility */
    void *shm_unused2;           /* ditto - used by DIPC */
    void *shm_unused3;           /* unused */
};

其中 struct ipc_perm 中存储了 共享内存中的基本信息，具体包含内容如下：

struct ipc_perm
{
    __kernel_key_t key; 
    __kernel_uid_t uid;
    __kernel_gid_t gid;
    __kernel_uid_t cuid;
    __kernel_gid_t cgid;
    __kernel_mode_t mode; 
    unsigned short seq;
};

共享内存虽然属于文件系统，但它的结构是经过特殊设计的，与文件系统中的 inode 那一套结构逻辑不一样

2.2 创建 shmget 

 创建共享内存时，需要借助 shmget 这个函数

#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

 

 

因为共享内存拥有自己的数据结构，所以 返回值 int 实际就是 shmid，类似于文件系统中的 fd，用来对不同的共享内存块进行操作

参数2为创建共享内存的大小，单位是字节，一般设为 4096 字节（4kb），与一个 PAGE 页大小相同，有利于提高 IO 效率

参数3是位图结构，类似于 open 函数中的参数3（文件打开方式），常用的选项有以下几个：

  1. IPC_CREAT 创建共享内存，如果存在，则使用已经存在的
  2. IPC_EXCL 避免使用已存在的共享内存，不能单独使用，需要配合 IPC_CREAT 使用，作用是当创建共享内存时，如果共享内存已经存在，则创建失败
  3. 权限 因为共享内存也是文件，所以权限可设为文件的起始权限 0666

而参数1比较特殊，key_t 实际就是对 int 进行了封装，表示一个数字，用来标识不同的共享内存块，可以理解为 inode，因为是标识值，所以必须确保 唯一性，需要使用函数 ftok 根据不同的 项目路径 + 项目编号 + 特殊的算法，生成一个碰撞率低的标识值，供操作系统对共享内存进行区分和调用

2.2.1关于key的获取

使用函数ftok生成key 

 

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

key_t ftok(const char *pathname, int proj_id);

关于 ftok 函数

 注意： 只有先让操作系统根据同一个 key 创建/打开 同一个共享内存，不同的进程才能看到同一份资源

 下面是创建 共享内存 的代码

common.h

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

using namespace std;

#define PAHTHNAME "." // 项目路径
#define PROJID 0X29C  // 项目编号

const int gsize = 4096;
const mode_t mode = 0666;

//将十进制数转为十六进制数
string toHEX(int x)
{
    char buffer[64];
    snprintf(buffer, sizeof buffer, "0x%x", x);
    return buffer;
}

// 获取key值
key_t getKey()
{
    key_t key = ftok(PAHTHNAME, PROJID);
    if (key == -1)
    {
        // 失败，终止进程
        cerr << "ftok fail!  "
             << "errno: " << errno << " | " << strerror(errno) << endl;
        exit(1);
    }
    return key;
}

// 共享内存助手
int shmHelper(key_t key,size_t size,int flags)
{
    int shmid = shmget(key,size,flags);
    if (shmid == -1)
    {
        // 失败，终止进程
        cerr << "shmget fail!  "
             << "errno: " << errno << " | " << strerror(errno) << endl;
        exit(2);
    }
    return shmid;
}

// 创建共享内存
int CreateShm(key_t key,size_t size)
{
    return shmHelper(key,size,IPC_CREAT|IPC_EXCL|mode);
}

// 获取共享内存
int getShm(key_t key,size_t size)
{
    return shmHelper(key,size,IPC_CREAT);
}

server.cc

#include <iostream>
#include "common.h"

using namespace std;

int main()
{
    // 服务端创建共享内存
    key_t key = getKey();
    int shmid = createShm(key, gsize);

    cout << "server key: " << toHEX(key) << endl;
    cout << "server shmid: " << shmid << endl;
    return 0;
}

client.cc

#include <iostream>
#include "common.h"

using namespace std;

int main()
{
    // 客户端打开共享内存
    key_t key = getKey();
    int shmid = getShm(key, gsize);

    cout << "client key: " << toHEX(key) << endl;
    cout << "client shmid: " << shmid << endl;
    return 0;
}

 

通过 shmget 和 ftok 函数获得唯一的 key 和 shmid

创建出来的共享内存可以通过 ipcs -m 查看

 

2.3释放共享内存

当我们再次运行程序时，会出现下面这种情况：

服务端运行失败，原因是 shmget 创建共享内存失败，这是因为服务端创建共享内存时，传递的参数为 IPC_CREAT | IPC_EXCL，其中 IPC_EXCL 注定了当共享内存存在时，创建失败

而客户端只是单纯的获取共享内存，同时也只传递了 IPC_CREAT 参数，所以运行才会成功

综上所述，服务端运行失败的根本原因是 待创建的共享内存已存在，如果想要成功运行，需要先将原共享内存释放

共享内存的释放方式主要有以下两种：

 2.3.1通过指令释放

可以直接在命令行中通过指令，根据 shmid 释放指定共享内存

ipcrm -m shmid

2.3.2通过共享内存控制函数释放

 这里先提前使用一下函数 shmctl，在服务端中加入删除共享内存的函数，当服务端运行结束时，自动删除共享内存

 

shmctl(shmid, IPC_RMID, NULL);

server.cc 

#include <iostream>
#include "common.hpp"

using namespace std;

int main()
{
    // 服务端创建共享内存
    key_t key = getKey();
    int shmid = CreateShm   (key, gsize);

    cout << "server key: " << toHEX(key) << endl;
    cout << "server shmid: " << shmid << endl;

        int n = 5;
    while(n)
    {
        //运行五秒后删除共享内存
        cout << n-- << endl;
        sleep(1);
    }

    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

 

 共享内存也被成功释放了，实际中会使用函数进行自动释放，因为手动释放比较麻烦

2.4进程关联 shmat 

 

共享内存在被成功创建后，进程还不 “认识” 它，只有让待通信进程都 “认识” 同一个共享内存后，才能进行正常通信，让进程 “认识” 共享内存这一操作称为 关联

当进程与共享内存关联后，共享内存才会 通过页表映射至进程的虚拟地址空间中的共享区中

需要使用 shmat 函数进行关联

 

 

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

void *shmat(int shmid, const void *shmaddr, int shmflg);

关于 shmat 函数

当进程与共享内存关联后，返回的就是共享内存映射至共享区的起始地址

  • 关联成功返回起始地址
  • 关联失败返回 (void*) -1

 

关于参数3，一般直接设为 0，表示关联后，共享内存属性为 默认读写权限，更多选项如下所示：

SHM_RDONLY 关联共享内存后只进行读取操作
SHM_RND 若 shmaddr 不为 NULL，则关联地址自动向下调整为 SHMLBA 的整数倍，SHMLBA 的值为 PAGE_SIZE，具体调整公式：shmaddr - (shmaddr % SHMLBA)

 

一般通信数据为字符，所以可以将 shmat 的返回值强转为 char*

下面是 服务端 和 客户端 关联共享内存 的代码

服务端睡五秒后结束，客户端睡三秒后就结束，监视窗口每隔2秒更新一次

 

server.cc

#include <iostream>
#include "common.h"

using namespace std;

int main()
{
    // 服务端创建共享内存
    key_t key = getKey();
    int shmid = createShm(key, gsize);

    cout << "server key: " << toHEX(key) << endl;
    cout << "server shmid: " << shmid << endl;

    char *start = (char*)shmat(shmid, NULL, 0);
    if ((void*)start == (void*)-1)
    {
        cerr << "shmat fail!"
             << "errno: " << errno << " | " << strerror(errno) << endl;
        shmctl(shmid, IPC_RMID, NULL);  //即使异常了，也要把共享内存释放
        exit(1);
    }

    //挂接成功后，睡五秒再释放
    printf("start: %p\n", start);
    sleep(5);

    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

client.cc 

 

#include <iostream>
#include "common.h"

using namespace std;

int main()
{
    // 客户端打开共享内存
    key_t key = getKey();
    int shmid = getShm(key, gsize);

    cout << "client key: " << toHEX(key) << endl;
    cout << "client shmid: " << shmid << endl;

    char *start = (char *)shmat(shmid, NULL, 0);
    if ((void *)start == (void *)-1)
    {
        cerr << "shmat fail!"
             << "errno: " << errno << " | " << strerror(errno) << endl;
        exit(1);
    }

    // 挂接成功后，睡三秒就结束
    printf("start: %p\n", start);
    sleep(3);

    return 0;
}

 

共享内存信息中的 nattch 表示当前共享内存中的进程关联数

注意： 程序运行结束后，会自动取消关联状态

2.5进程去关联 shmdt

 可以手动去关联，即使用函数 shmdt

 

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

 int shmdt(const void *shmaddr);

这个函数使用非常简单，将已关联的共享内存地址传递进行去关联即可

返回值：去关联成功返回 0，失败返回 -1，并将错误码设置

如同关闭 FILE*、fd、free 等一些列操作一样，当我们关联共享内存，使用结束后，需要进行去关联，否则会造成内存泄漏（指针指向共享内存，访问数据）

所以需要在上面的代码结尾加上 shmdt(start) 去关联

注意：

  • 共享内存在被删除后，已成功挂接的进程仍然可以进行正常通信，不过此时无法再挂接其他进程

  • 共享内存被提前删除后，状态 status 变为 销毁 dest

2.6共享内存控制 shmctl

 System V 标准中还为共享内存提供了一个控制函数 shmctl，其原型如下图所示：

 

 关于 shmctl 函数

 

 

之前在释放共享内存时，我们就已经使用过了 shmctl，给参数2传入的是 IPC_RMID，表示删除共享内存，除此之外，还可以给参数2传递以下动作：

  • IPC_STAT 用于获取或设置所控制共享内存的数据结构
  • IPC_SET 在进程有足够权限的前提下，将共享内存的当前关联值设置为 buf 数据结构中的值

buf 就是共享内存的数据结构，可以使用 IPC_STAT 获取，也可以使用 IPC_SET 设置

当参数2为 IPC_RMID 时，参数3可以不用传递；其他两种情况都需传递 struct shmid_ds *buf

演示代码：通过 shmctl 获取共享内存的数据结构，并从中获取 pid、key

 

#include <iostream>
#include "common.h"

using namespace std;

int main()
{
    // 服务端创建共享内存
    key_t key = getKey();
    int shmid = createShm(key, gsize);

    cout << "getpid(): " << getpid() << endl;
    cout << "server key: " << toHEX(key) << endl;

    char *start = (char*)shmat(shmid, NULL, 0); //去关联
    if ((void*)start == (void*)-1)
    {
        cerr << "shmat fail!"
             << "errno: " << errno << " | " << strerror(errno) << endl;
        shmctl(shmid, IPC_RMID, NULL);  //即使异常了，也要把共享内存释放
        exit(1);
    }

    struct shmid_ds buf;
    int n = shmctl(shmid, IPC_STAT, &buf);
    if (n == -1)
    {
        cerr << "shmctl fail!"
             << "errno: " << errno << " | " << strerror(errno) << endl;
        shmctl(shmid, IPC_RMID, NULL);  //即使异常了，也要把共享内存释放
        exit(1);
    }

    cout << "==================" << endl;
    cout << "buf.shm_cpid: " << buf.shm_cpid << endl;
    cout << "buf.shm_perm.__key: " << toHEX(buf.shm_perm.__key) << endl;


    shmdt(start);   //去关联
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

通过程序证明了 共享内存确实有自己的数据结构

结论： 共享内存 = 共享内存的内核数据结构（struct shmid_ds） + 真正开辟的空间

 3.共享内存的简单实用

 

当两个进程与同一块共享内存成功关联后，可以直接对该区域进行读写操作，就像 父子进程读取同一个数据一样，不过不能进行写入，因为会发生 写时拷贝 机制，拷贝共享数据

但共享内存就不一样了，真·共享，不会发生 写时拷贝

简单使用共享内存流程如下：

  • 创建、关联共享内存
  • 客户端向服务端写入数据（字符串）
  • 服务端每隔十秒读取一次

common.hpp

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

using namespace std;

#define PAHTHNAME "." // 项目路径
#define PROJID 0X29C  // 项目编号



enum{
    SERVER = 0,
    CLIENT = 1
};

class shm
{
public:
    shm(int id)
    :_id(id)
    {
        //创建、打开共享内存
        _key = getKey();
        if(id == SERVER)
        {
            _shmid = shmHelper(_key,gsize,IPC_CREAT|IPC_EXCL|mode);
        }
        else 
        _shmid = shmHelper(_key,gsize,IPC_CREAT);
        //关联共享内存
        _start = shmat(_shmid,NULL,0);
        if(_start = (void*)-1)
        {
            cerr<<"fail shmat"
                <<"errno"<<errno<<"|"<<strerror(errno)<<endl;
                exit(-1);
        }
    }
    ~shm()
    {
        //去关联
        int n = shmdt(_start);
        if(n == -1)
        {
             cerr << "shmat fail!"
                 << "errno: " << errno << " | " << strerror(errno) << endl;
                 exit(-1);
        }
        //根据身份删除共享内存
        if(_id == SERVER)
            shmctl(_shmid, IPC_RMID, NULL);


    }

    // 获取key值
key_t getKey()
{
    key_t key = ftok(PAHTHNAME, PROJID);
    if (key == -1)
    {
        // 失败，终止进程
        cerr << "ftok fail!  "
             << "errno: " << errno << " | " << strerror(errno) << endl;
        exit(1);
    }
    return key;
}

        int getShmID() const
    {
        return _shmid;
    }

    void *getStart() const
    {
        return _start;
    }
    
protected:
    static const int gsize = 4096;
    static const mode_t mode = 0666;

    //将十进制数转为十六进制数
    string toHEX(int x)
    {
        char buffer[64];
        snprintf(buffer, sizeof buffer, "0x%x", x);
        return buffer;
    }
    // 共享内存助手
    int shmHelper(key_t key,size_t size,int flags)
    {
        int shmid = shmget(key,size,flags);
        if (shmid == -1)
        {
            // 失败，终止进程
            cerr << "shmget fail!  "
                << "errno: " << errno << " | " << strerror(errno) << endl;
            exit(2);
        }
        return shmid;
    }

private:
    key_t _key;
    int _id;
    void *_start;
    int _shmid = 0;
};

server.cc

 

#include <iostream>
#include <cstring>
#include <unistd.h>
#include "common.hpp"

using namespace std;

int main()
{
    // 服务端
    shm s(SERVER);

    // 获取共享内存起始地址
    char *start = (char *)s.getStart();

    // 开始通信
    while (true)
    {
        cout << "server get: " << start << endl;

        //读取到26个字母后，关闭服务端
        if (strlen(start) == 26)
            break;

        sleep(1);
    }

    return 0;
}

client.cc

#include <iostream>
#include "common.hpp"

using namespace std;

int main()
{
    // 客户端
    shm c(CLIENT);

    // 获取共享内存起始地址
    char *start = (char *)c.getStart();

    // 开始通信
    int n = 0;
    printf("client sent: ");
    fflush(stdout); //细节：强制刷新缓冲区

    //写入26个字母后，终止客户端
    while (n < 26)
    {
        start[n] = ('A' + n);
        printf("%c", start[n]);
        fflush(stdout); //细节：强制刷新缓冲区

        n++;
        start[n] = '\0';
        sleep(1);
    }
    cout << endl;

    return 0;
}

注意：

  • 如果想实现 client 不按回车打印数据，需要使用 fflush 手动刷新 printf 的缓冲区
  • 需要先启动服务端，才启动客户端；如果先启动了客户端，会导致客户端创建共享内存后，无法释放，程序也无法运行
  • 因为共享内存不区分读端与写端，只要关联了，两者都可以进行读写

4.共享内存的知识补充

4.1共享内存的大小

 在上面的代码中，我们将共享内存的大小设为 4096 字节，即一个 PAGE 页的大小（4kb）；如果申请 4097 字节大小的共享内存，操作系统实际上会分配 8192 字节（8kb 的空间），但供共享内存使用的只有 4097 字节。

为什么会出现这种现象？

  • 因为操作系统为了避免因非法操作导致出现越界访问问题，所以会开辟 PAGE 页的整数倍大小空间，多开辟的空间不会给共享内存时，主要是用来检测是否出现了越界访问

4.2共享内存快的原因 

共享内存 IPC 快的秘籍在于 减少数据拷贝（IO），IO 是很慢、很影响效率的

比如在使用管道通信时，需要经过以下几个步骤：

  1. 从进程 A 中读取数据（IO）
  2. 打开管道，然后通过系统调用将数据写入管道（IO）
  3. 通过系统调用从管道读取数据（IO）
  4. 将读取到的数据输出至进程 B（IO）

 

但共享内存就不一样，直接访问同一块区域进行数据读写

在使用共享内存通信时，只需要经过以下两步：

  1. 进程 A 直接将数据写入共享内存中
  2. 进程 B 直接从共享内存中读取数据

显然，使用共享内存只需要经过 2 次 IO 

 

所以共享内存的秘籍是 减少拷贝（IO）次数

  • 得益于共享内存的这种特性，可以让进程通信的时候，减少拷贝次数，所以共享内存是所有进程通信中，速度最快的

4.3共享内存缺点 

 

共享内存这么快，为什么不直接只使用共享内存呢？

因为快是要付出代价的，因为 “快” 导致共享内存有以下缺点：

多个进程无限制地访问同一块内存区域，导致共享内存中的数据无法确保安全
即 共享内存 没有同步和互斥机制，某个进程可能数据还没写完，就被别人读走了，或者被别人覆盖了
总的来说，不加规则限制的共享内存是不推荐使用的

5.共享内存实操-配合命名管道完成通信 

 共享内存如果不加以控制的话，很难实现管道般的通信，所以我们要对它进行改造

5.1逻辑设计

 共享内存的特点是 无读写规则限制，进程即可读也可写，容易造成冲突，因此我们可以对其加以限制，所使用的工具正是上文中学习的 命名管道

场景：两个独立进程使用共享内存实现通信

所需要资源：一块共享内存，两条命名管道

  • 一条管道负责 服务端写，客户端读，另一条管道则负责 服务端读，客户端写，间接实现 双向通知

 

 

所以我们这个程序的逻辑设计流程如下：

  1. 创建共享内存，将服务端、客户端进程关联
  2. 创建两条管道，分别让服务端、客户端以不同方式打开
  3. 进行通信

5.2 代码部分

common.h

#include <iostream>
#include <cerrno>
#include <cassert>
#include <cstring>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

using namespace std;

#define PATHNAME "." // 项目名
#define PROJID 0x29C // 项目编号

// 两条管道名
const char *fifo_name1 = "fifo1";
const char *fifo_name2 = "fifo2";

enum
{
    SERVER = 0,
    CLIENT = 1
};

class shm
{
public:
    shm(int id)
        : _id(id)
    {
        _key = getKey(); // 获取 key

        // 根据不同的身份:
        //    创建 / 打开 共享内存
        //    创建 / 打开 命名管道
        if (_id == SERVER)
        {
            _shmid = shmHelper(_key, gsize, IPC_CREAT | IPC_EXCL | mode);

            int n = mkfifo(fifo_name1, mode);
            assert(n != -1);
            (void)n;

            n = mkfifo(fifo_name2, mode);
            assert(n != -1);
            (void)n;

            // 服务端以写打开命名管道1，以读打开命名管道2
            _wfd = open(fifo_name1, O_WRONLY);
            _rfd = open(fifo_name2, O_RDONLY);
        }
        else
        {
            _shmid = shmHelper(_key, gsize, IPC_CREAT);

            // 客户端以读打开命名管道1，以写打开命名管道2
            _rfd = open(fifo_name1, O_RDONLY);
            _wfd = open(fifo_name2, O_WRONLY);
        }

        // 关联共享内存
        _start = shmat(_shmid, NULL, 0); // 关联
        if (_start == (void *)-1)
        {
            cerr << "shmat fail!"
                 << "errno: " << errno << " | " << strerror(errno) << endl;
            exit(1);
        }
    }

    ~shm()
    {
        // 关闭fd
        close(_wfd);
        close(_rfd);

        // 去关联
        int n = shmdt(_start);
        if (n == -1)
        {
            cerr << "shmdt fail!"
                 << "errno: " << errno << " | " << strerror(errno) << endl;
            exit(1);
        }

        // 根据不同的身份:
        //    判断是否需要删除管道文件
        //    判断是否需要删除共享内存
        if (_id == SERVER)
        {
            unlink(fifo_name1);
            unlink(fifo_name2);
            shmctl(_shmid, IPC_RMID, NULL);
        }
    }

    key_t getKey() const
    {
        key_t key = ftok(PATHNAME, PROJID);
        if (key == -1)
        {
            // 失败，终止进程
            cerr << "ftok fail!  "
                 << "errno: " << errno << " | " << strerror(errno) << endl;
            exit(1);
        }

        return key;
    }

    int getShmID() const
    {
        return _shmid;
    }

    void *getStart() const
    {
        return _start;
    }

    int getWFD() const
    {
        return _wfd;
    }

    int getRFD() const
    {
        return _rfd;
    }

protected:
    static const int gsize = 4096;
    static const mode_t mode = 0666;

    // 共享内存助手
    int shmHelper(key_t key, size_t size, int flags)
    {
        int shmid = shmget(key, size, flags);
        if (shmid == -1)
        {
            // 失败，终止进程
            cerr << "shmget fail!  "
                 << "errno: " << errno << " | " << strerror(errno) << endl;
            exit(2);
        }

        return shmid;
    }

private:
    key_t _key;
    int _shmid = 0;
    void *_start;
    int _wfd; // 写端 与 读端 fd
    int _rfd;
    int _id; // 身份标识符，用来区分服务端与客户端
};

 server.cc

 

#include <iostream>
#include <cstring>
#include <unistd.h>

#include "common.hpp"

using namespace std;

int main()
{
    // 服务端：读取
    shm s(SERVER);

    char *start = (char *)s.getStart();
    int wfd = s.getWFD();
    int rfd = s.getRFD();

    const char *str = "yes";

    // 因为是服务端先启动，所以直接先向管道中发出 yes 的指令
    write(wfd, str, strlen(str));

    char buff[64];
    while (true)
    {
    	// 等待客户端发出操作命令
        int n = read(rfd, buff, sizeof(buff) - 1);
        buff[n] = 0;

        if (n > 0)
        {
            if (strcasecmp(str, buff) == 0)
            {
                // 客户端允许服务端进行读取
                int i = 0;
                while (start[i])
                {
                    buff[i] = start[i];
                    i++;
                }
                buff[i] = 0;

                printf("server read# %s\n", buff);

                if (strcasecmp("exit", buff) == 0)
                    break;

                // 读取完成，通知客户端写入
                write(wfd, str, strlen(str));
            }
        }
        else if (n == 0)
        {
            cerr << "客户端未从管道中读取到数据" << endl;
        }
        else
        {
            cerr << "读取异常" << endl;
            break;
        }
    }

    return 0;
}

client.cc 

#include <iostream>
#include <cstring>
#include <unistd.h>

#include "common.hpp"

using namespace std;

int main()
{
    // 客户端：写入
    shm c(CLIENT);

    char *start = (char *)c.getStart();
    int wfd = c.getWFD();
    int rfd = c.getRFD();

    const char *str = "yes";

    srand((size_t)time(NULL));

    char buff[64];
    while (true)
    {
    	// 等待服务端发出操作命令
        int n = read(rfd, buff, sizeof(buff) - 1);
        buff[n] = 0;

        if (n > 0)
        {
            if (strcasecmp(str, buff) == 0)
            {
                printf("client write# ");
                fflush(stdout);

                fgets(buff, sizeof buff, stdin);
                int i = 0;
                while(buff[i] != '\n')
                {
                    start[i] = buff[i];
                    i++;
                }
                buff[i] = start[i] = 0;


                // 写入完成，通知服务端读取
                write(wfd, str, strlen(str));

                if (strcasecmp("exit", buff) == 0)
                    break;
            }
        }
        else if (n == 0)
        {
            cerr << "客户端未从管道中读取到数据" << endl;
        }
        else
        {
            cerr << "读取异常" << endl;
            break;
        }
    }

    return 0;
}

5.3注意事项 

在这份代码中，我们需要注意 谁先启动的问题，因为是两条命名管道，刚开始都在等对方写入数据，所以必须由一方先出击，打破这种 无限等待 的破局，建议谁读取，谁就先通知，即在执行通信代码前，通知 写入方 可以写入数据了

关于其他值得 注意 的点：

打开命名管道文件时，需要特别注意，别打开错了
在通信结束后，需要删除命名管道文件

总结：

以上就是本次关于 Linux 进程间通信之 共享内存 的全部内容了，共享内存 是所有 IPC 中最快的一种，因为它省去了很多不必要的 IO 操作，进程直接对话进程，效率极高，不过在狂飙的后果就是不安全，因此在实现 共享内存 实现进程间通信时，需要借助其他 IPC 方式控制共享内存，这样才能合理发挥 共享内存 的实力

 

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值