【Linux进程通信】system V下的共享内存

最新推荐文章于 2024-09-14 19:00:09 发布

W…Y

最新推荐文章于 2024-09-14 19:00:09 发布

阅读量777

点赞数 30

分类专栏： Linux 文章标签： linux 运维服务器 c++ java 机器学习 ai

本文链接：https://blog.csdn.net/m0_74755811/article/details/140082741

版权

Linux 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

W...Y的主页 😊

代码仓库分享 💕

前言：之前我们已经掌握了进程间的管道通信，匿名管道和命名管道。匿名管道必须进程要血缘关系，而命名管道不需要血缘关系，两个毫不相干的进程就可以进行通信。上面两种是基于文件的通信，今天我们继续来学习本地进程间的通信——共享内存。

system V

System V 消息队列
System V 共享内存
System V 信号量

共享内存

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。

共享内存之间的通信可以是两个毫不相干的进程进行，之所以进程具有独立性就是因为每个进程都有属于自己独立的地址空间通过页表进行映射到物理内存中去。

而共享内存顾名思义就是在物理内存中开辟一块空间通过页表映射，传到需要进程的地址空间的共享区中，然后返回共享空间的起始地址即可进行使用。但是这些开辟空间，修改地址空间页表等都需要操作系统完成，所以我们就要学习一些系统调用。

共享内存函数和指令

shmget函数

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

在操作系统中有不同的进程之间在对应通信，所以我们就可以创建多个共享内存在操作系统中，所以共享内存要被操作系统所管理。这就要创建关于共享内存的数据结构，里面存储的是共享内存的属性。那我们必须保证两个进程通信之间必须看到同一份资源，所以我们就要有一个共享内存唯一标识符。shmget函数的第一个参数是共享内存的唯一标识符key。
key这个参数是要让用户去传入的，因为进程间都是相互独立的，所以我们必须要以相同的算法进行计算得出相同的结果才能使两个进程看到同一份资源(约定好的)。所以在系统调用中提供了可以生成key值的函数：

这两个参数有用户指定，一个字符串一个int值。

函数的第三个参数是一个宏，我们最常用的两个是IPC_CREAT和IPC_EXCL。
IPC_CREAT：如果共享内存不存在就创建一个，如果共享内存已经存在就获取它。
IPC_ECXCL：不能单独使用没有意义。
IPC_CREAT|IPC_ECXL：不存在就创建一个，如果共享内存存在就出错返回。

shmat函数

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

说明：
shmaddr为NULL，核心自动选择一个地址
shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr -
(shmaddr % SHMLBA)
shmflg=SHM_RDONLY，表示连接操作用来只读共享内存

shmdt函数

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

shmctl函数

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

shmctl函数既可以删除共享内存，也可以进行获取其中的属性。当我们需要删除一个共享内存时我们只需要使用前两个参数即可，cmd使用IPC_RMID。而需要获取其中的内存属性我们需要创建一个struct shmid_ds结构体，cmd使用IPC_STAT参数即可。

在共享内存中，如果进程结束我们没有主动进行释放则共享内存会一直存在，而文件操作当进程退出时文件会被操作系统释放掉。所以我们将共享内存使用完后要进行释放。

我们可以使用指令查询系统中的共享内存、信号量以及消息队列：ipcs

而我们需要查询共享内存使用选项 ipcs -m查看。删除时使用ipcrm -m + shmid即可。

上图中的表中的perms是共享内存的权限，当我们在shmget时第三个参数中可以使用666等来规定其权限。nattch是一块共享内存的挂接数，我们使用shmctl函数进行挂接，挂接成功就会+1.

实例代码

在共享内存通信时，当写入放不写数据时，读取方会一直进行读取。但是在管道中不存在这种情况。所以共享内存不提供进程间协同的任何机制。这是共享内存的缺点，这个缺点会导致数据不一致现象。我们想要维护缺点我们可以使用信号量来完善，但是这里我们使用更简单的管道来解决问题。

测试代码结构

makefile：

.PHONY:all
all:shm_client shm_server

shm_server:ShmServer.cc
	g++ -o $@ $^ -std=c++11
shm_client:ShmClient.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f shm_client shm_server

Comm.hpp:

#pragma once

#include <iostream>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>

using namespace std;

const char *pathname = "/home/why";
const int proj_id = 0x66;

// 在内核中，共享内存的大小是以4KB为基本单位的. 你只能用你申请的大小。建议申请大小是n*4KB
const int defaultsize = 4096; // 单位是字节

std::string ToHex(key_t k)
{
    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "0x%x", k);
    return buffer;
}

key_t GetShmKeyOrDie()
{
    key_t k = ftok(pathname, proj_id);
    if (k < 0)
    {
        std::cerr << "ftok error, errno : " << errno << ", error string: " << strerror(errno) << std::endl;
        exit(1);
    }
    return k;
}

int CreateShmOrDie(key_t key, int size, int flag)
{
    int shmid = shmget(key, size, flag);
    if (shmid < 0)
    {
        std::cerr << "shmget error, errno : " << errno << ", error string: " << strerror(errno) << std::endl;
        exit(2);
    }
    return shmid;
}

int CreateShm(key_t key, int size)
{
    // IPC_CREAT: 不存在就创建，存在就获取
    // IPC_EXCL: 没有意义
    // IPC_CREAT | IPC_EXCL: 不存在就创建，存在就出错返回
    return CreateShmOrDie(key, size, IPC_CREAT | IPC_EXCL | 0666);
}

int GetShm(key_t key, int size)
{
    return CreateShmOrDie(key, size, IPC_CREAT);
}

void DeleteShm(int shmid)
{
    int n = shmctl(shmid, IPC_RMID, nullptr);
    if (n < 0)
    {
        std::cerr << "shmctl error" << std::endl;
    }
    else
    {
        std::cout << "shmctl delete shm success, shmid: " << shmid << std::endl;
    }
}

void ShmDebug(int shmid)
{
    struct shmid_ds shmds;
    int n = shmctl(shmid, IPC_STAT, &shmds);
    if (n < 0)
    {
        std::cerr << "shmctl error" << std::endl;
        return;
    }
    std::cout << "shmds.shm_segsz: " << shmds.shm_segsz << std::endl;
    std::cout << "shmds.shm_nattch:" << shmds.shm_nattch << std::endl;
    std::cout << "shmds.shm_ctime:" << shmds.shm_ctime << std::endl;
    std::cout << "shmds.shm_perm.__key:" << ToHex(shmds.shm_perm.__key) << std::endl;
}

void *ShmAttach(int shmid)
{
    void *addr = shmat(shmid, nullptr, 0);
    if ((long long int)addr == -1)
    {
        std::cerr << "shmat error" << std::endl;
        return nullptr;
    }
    return addr;
}

void ShmDetach(void *addr)
{
    int n = shmdt(addr);
    if (n < 0)
    {
        std::cerr << "shmdt error" << std::endl;
    }
}

Fifo.hpp

#ifndef __COMM_HPP__
#define __COMM_HPP__

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

using namespace std;

#define Mode 0666
#define Path "./fifo"

class Fifo
{
public:
    Fifo(const string &path = Path) : _path(path)
    {
        umask(0);
        int n = mkfifo(_path.c_str(), Mode);
        if (n == 0)
        {
            cout << "mkfifo success" << endl;
        }
        else
        {
            cerr << "mkfifo failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        }
    }
    ~Fifo()
    {
        int n = unlink(_path.c_str());
        if (n == 0)
        {
            cout << "remove fifo file " << _path << " success" << endl;
        }
        else
        {
            cerr << "remove failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        }
    }

private:
    string _path; // 文件路径+文件名
};

class Sync
{
public:
    Sync() : rfd(-1), wfd(-1)
    {
    }
    void OpenReadOrDie()
    {
        rfd = open(Path, O_RDONLY);
        if (rfd < 0)
            exit(1);
    }
    void OpenWriteOrDie()
    {
        wfd = open(Path, O_WRONLY);
        if (wfd < 0)
            exit(1);
    }
    bool Wait()
    {
        bool ret = true;
        uint32_t c = 0;
        ssize_t n = read(rfd, &c, sizeof(uint32_t));
        if (n == sizeof(uint32_t))
        {
            std::cout << "server wakeup, begin read shm..." << std::endl;
        }
        else if (n == 0)
        {
            ret = false;
        }
        else
        {
            return false;
        }
        return ret;
    }
    void Wakeup()
    {
        uint32_t c = 0;
        ssize_t n = write(wfd, &c, sizeof(c));
        assert(n == sizeof(uint32_t));

        std::cout << "wakeup server..." << std::endl;
    }
    ~Sync() {}

private:
    int rfd;
    int wfd;
};

#endif

shmclient.cc

#include "Comm.hpp"
#include "Fifo.hpp"
#include <unistd.h>

int main()
{
    key_t key = GetShmKeyOrDie();
    std::cout << "key: " << ToHex(key) << std::endl;
    // sleep(2);

    int shmid = GetShm(key, defaultsize);
    std::cout << "shmid: " << shmid << std::endl;
    // sleep(2);

    char *addr = (char *)ShmAttach(shmid);
    std::cout << "Attach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;
    // sleep(5);

    memset(addr, 0, defaultsize);
    Sync syn;
    syn.OpenWriteOrDie();

    // 可以进行通信了
    for (char c = 'A'; c <= 'Z'; c++) // pipe, fifo, ->read/write->系统调用， shm -> 没有使用系统调用！！
    {
        addr[c - 'A'] = c;
        sleep(1);
        syn.Wakeup();
    }

    ShmDetach(addr);
    std::cout << "Detach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;
    sleep(5);

    return 0;
}

shmserver.cc

#include "Comm.hpp"
#include "Fifo.hpp"
#include <unistd.h>

int main()
{
    // 1. 获取key
    key_t key = GetShmKeyOrDie();
    std::cout << "key: " << ToHex(key) << std::endl;
    // sleep(2);

    // 2. 创建共享内存
    int shmid = CreateShm(key, defaultsize);
    std::cout << "shmid: " << shmid << std::endl;
    // sleep(2);

    // ShmDebug(shmid);
    // 4. 将共享内存和进程进行挂接(关联)
    char *addr = (char *)ShmAttach(shmid);
    std::cout << "Attach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;

    // 0. 先引入管道
    Fifo fifo;
    Sync syn;
    syn.OpenReadOrDie();

    // 可以进行通信了
    for(;;)
    {
        if(!syn.Wait()) break;
        cout << "shm content: " << addr << std::endl;
    }

    ShmDetach(addr);
    std::cout << "Detach shm success, addr: " << ToHex((uint64_t)addr) << std::endl;

    // 3. 删除共享内存
    DeleteShm(shmid);
    return 0;
}

这样我们就可以进行一个协调通信了。

消息对列和共享内存比较想且已经淘汰，而信号量我们会在线程中详细讲解，在这一块就不提及了。

以上就是本次全部内容，感谢大家观看！