【Linux】进程间通信 -- system V共享内存

共享内存的原理

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

理解:

1. 进程间通信，是专门设计的，用来IPC
2. 共享内存是一种通信方式，所有想通信的进程，都可以用
3. OS中一定可能会同时存在的很多的共享内存

---

共享内存的用法

共享内存的概念：

通过让不同的进程，看到同一个内存块的方式，就叫做共享内存

1.使用shmget生成共享内存

函数参数int shmflg(标记位传参)：
lPC_CREAT:如果不存在，创建之，如果存在，获取之
IPC_EXCL:

1. 无法单独使用
2. IPC_CREAT|IPC_EXCL:如果不存在，创建之，如果存在，就出错返回
   (给用户如果创建成功，一定是一个新的shm!)

shmget返回值：在不同操作系统可能不一样，它虽然是数组下标，但是它跟我们之前学习过的文件系统的下标是不一样的，是两套体系，而它的返回值我们把它当成是一个标识符就行了

函数参数key_t key：
我们是只有shmget()创建完以后才有返回值，但是为了保证两个需要通信的进程看到的是同一个内存块，需要有标识符确定。而这个key值是什么不重要，重要的是能进行唯一性标识最重要。
我们在生成key值需要调用另外一个函数：ftok

2.使用ftok使得进程能看到同一内存块

我们只需要在ftok的参数传入相同的pathname与proj_id那么它生成的key值也一定是一样的，然后我们的两个进程就能通过这个key值找到这个内存块
ftok函数的原型如下：

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

pathname参数是一个指向文件路径名的指针，proj_id参数是一个整数值。ftok函数会根据pathname和proj_id生成一个key值，并将其返回。

使用 ftok 函数时，需要注意以下几点：

1. pathname 参数必须指向一个存在的文件，否则 ftok 函数会返回错误。
2. proj_id 参数是一个可以自定义的整数值，用于在同一个文件的不同共享内存区域之间进行区分。如果不同的共享内存区域使用相同的 proj_id 值，则它们将被视为同一个共享内存区域。
3. key 值的生成是基于 st_dev 和 st_ino 两个文件属性值的。因此，如果 pathname 参数对应的文件属性值发生了改变，那么生成的 key 值也会发生改变。

3.模拟创建共享内存查看key值与shmid值

comm.hpp:

#ifndef _COMM_HPP_
#define _COMM_HPP_

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

#define PATHNAME "."
#define PROJ_ID  0x66
// 共享内存的大小，一般建议是4KB的整数倍
// 系统分配共享内存是以4KB为单位的！ --- 内存划分内存块的基本单位Page
#define MAX_SIZE 4096  // --- 内核给你的会向上取整， 内核给你的，和你能用的，是两码事
key_t getKey()
{
    key_t k = ftok(PATHNAME, PROJ_ID); //可以获取同样的一个Key！
    if(k < 0)
    {
        // cin, cout, cerr -> stdin, stdout, stderr -> 0, 1, 2
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(1);
    }
    return k;
}
int getShmHelper(key_t k, int flags)
{
    int shmid = shmget(k, MAX_SIZE, flags);
    if(shmid < 0)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(2);
    }
    return shmid;
}

int getShm(key_t k)
{
    return getShmHelper(k, IPC_CREAT);
}

int createShm(key_t k)
{
    return getShmHelper(k, IPC_CREAT | IPC_EXCL | 0600);
}
#endif

shm_server.cpp:

#include "comm.hpp"
#include <unistd.h>
int main()
{
    key_t k = getKey(); 
    printf("key: 0x%x\n", k); // key
    int shmid = createShm(k);
    printf("shmid: %d\n", shmid); //shmid 
    delShm(shmid);
    return 0;
}

shm_client.cpp:

#include "comm.hpp"
#include <unistd.h>

int main()
{
    key_t k = getKey(); 
    printf("key: 0x%x\n", k);
    int shmid = getShm(k);
    printf("shmid: %d\n", shmid);
    return 0;
}

再谈key

在前面我们说过，OS中那么多进程需要通信，当然共享内存也可能同时存在很多，由于进程独立性，共享内存肯定是OS生成的，那么OS生成这些共享内存肯定也需要对其进行管理 -> 管理的方法：先描述再组织：
共享内存 = 物理内存块 + 共享内存相关属性

在创建共享内存时，为了保证共享内存存在系统中是唯一的，是使用key标识

共享内存标识符shmid是一个整数，由操作系统分配并唯一标识共享内存段。在使用共享内存时，不同的进程可以通过共享内存标识符访问同一个共享内存段

key是要shmget，设置进入共享内存属性中的！用来表示该共享内存，在内核中的唯一性！！
shmid类似于fd，而key类似于inode，shmid与key的关系类似锁与钥匙

IPC资源

ipc资源的特征：

按道理我们的bash结束就代表这个进程结束，那么我们继续执行却发现创建失败，这是为什么？
共享内存的生命周期是随OS的，而不是随进程的–这是所有system V版本的共性

查看IPC资源：

ipcs -m/-q/-s

删除这个资源：

ipcrm -m (shmid值)2

直观上你可能想使用key值去删除，因为key值具有唯一性，但是 不是，因为key值仅仅只是内核里面用来标识唯一性的，并不是让用户去操纵共享内存的，而指令是在应用层，用户要使用经常用来控制共享内存的id去操纵它，也就是shmid的值

4.shmctl对共享内存进行控制

函数原型：

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
//成功返回0，失败返回-1并设置errno变量以指示错误类型

参数cmd是一个控制命令，用于指定对共享内存的操作类型，常见的操作类型包括：

• IPC_STAT：获取共享内存的状态信息，将共享内存的状态信息保存在buf参数指向的shmid_ds结构体中。
• IPC_SET：设置共享内存的状态信息，将buf参数指向的shmid_ds结构体中的状态信息应用到共享内存中。
• IPC_RMID：删除共享内存，将共享内存从系统中删除。
• IPC_INFO：获取系统中IPC机制的状态信息，将IPC机制的状态信息保存在buf参数指向的ipc_info结构体中。
• SHM_LOCK：锁定共享内存，防止它被换出到交换空间中。
• SHM_UNLOCK：解锁共享内存，允许它被换出到交换空间中

参数buf是一个指向共享内存的数据结构shmid_ds的指针，用于获取和修改共享内存的状态信息。shmid_ds结构体定义在<sys/shm.h>头文件中，包含了共享内存的各种属性信息，例如共享内存的大小、创建时间、最后一次连接时间、最后一次操作时间、当前连接数等信息。

• 参数buf如果传nullptr的话,shmctl()函数会忽略buf参数，并且不会获取或修改共享内存的状态信息。
• 如果应用程序不需要获取或修改共享内存的状态信息，可以将buf参数传递为NULL，这样可以简化代码并提高程序的效率。
• 如果应用程序需要获取或修改共享内存的状态信息，那么必须传递一个有效的shmid_ds结构体指针作为buf参数，否则shmctl()函数将会返回错误并设置errno变量

struct shmid_ds {
    struct ipc_perm shm_perm;    /* Ownership and permissions */
    size_t          shm_segsz;   /* Size of segment (bytes) */
    time_t          shm_atime;   /* Last attach time */
    time_t          shm_dtime;   /* Last detach time */
    time_t          shm_ctime;   /* Last change time */
    pid_t           shm_cpid;    /* PID of creator */
    pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
    shmatt_t        shm_nattch;  /* No. of current attaches */
    ...
};

封装：删除共享内存：

//comm.hpp
void delShm(int shmid)
{
    if(shmctl(shmid, IPC_RMID, nullptr) == -1)
    {
        std::cerr << errno << " : " << strerror(errno) << std::endl;
    }
}

5.shmat将共享内存段连接到进程地址空间

函数原型：

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

这个void*的返回值就等价于以前的malloc的返回值

函数参数：
参数shmaddr是指定共享内存连接的地址

• 如果shmaddr参数的值为0或NULL，操作系统会自动选择一个可用的地址作为共享内存的连接地址，并返回该地址。
• 如果shmaddr参数的值不为0或NULL，则将共享内存连接到指定的地址，这种情况应用程序需要注意选择合适的共享内存连接地址，以避免与其他进程或共享库发生地址冲突。通常情况下，应用程序可以将shmaddr参数设置为一个特定的地址或者使用一个已经分配好的地址

参数shmflg是用于指定共享内存连接的标志，它控制共享内存连接的行为。shmflg参数可以是以下标志的按位或组合：

• SHM_RDONLY：只读访问共享内存，即使共享内存段是可写的。
• SHM_RND：将shmaddr参数舍入到系统页面大小的整数倍。这个标志在shmaddr参数不为0或NULL时才有意义。
• SHM_REMAP：将共享内存连接到一个新的地址，如果shmaddr参数不为0或NULL，则将共享内存连接到指定的地址。
• SHM_EXEC：允许执行共享内存中的代码。这个标志只在某些体系结构上有意义。
• IPC_NOWAIT：非阻塞模式，如果连接不可用，则立即返回错误而不是等待。
• SHM_DEST：在共享内存段上设置IPC_RMID标志，表示共享内存段已经被删除。
• SHM_HUGETLB：使用大页面来分配共享内存，以提高性能和效率。

不是所有的标志都适用于所有的平台和操作系统，因此在使用shmat()函数时，应该根据具体平台和操作系统的要求选择合适的标志，并正确设置shmflg参数。

封装：将当前进程贴到共享内存上：

//comm.hpp
void *attachShm(int shmid)
{
    void *mem = shmat(shmid, nullptr, 0); //64系统，8
    if((long long)mem == -1L)
    {
        std::cerr <<"shmat: "<< errno << ":" << strerror(errno) << std::endl;
        exit(3);
    }
    return mem;
}

6.shmdt将共享内存段与当前进程脱离

函数原型：

int shmdt(const void *shmaddr);

函数参数：
shmdt()函数的参数shmaddr是共享内存连接的地址，它指向共享内存段的起始地址。该地址是由shmat()函数返回的，用于标识应用程序与共享内存段之间的连接。

封装：

//comm.hpp
void detachShm(void *start)
{
    if(shmdt(start) == -1)
    {
        std::cerr <<"shmdt: "<< errno << ":" << strerror(errno) << std::endl;
    }
}

断开与共享内存段的连接并不会删除共享内存段，只是将该连接从应用程序的地址空间中删除。如果希望删除共享内存段，应该在最后一个使用共享内存段的进程断开连接后，调用shmctl()函数将共享内存段标记为删除状态，然后等待所有进程都将其连接断开后，再调用shmctl()函数将共享内存段从系统中删除。

7.创建共享内存通信-读取端

shm_server.cpp:

#include "comm.hpp"
#include <unistd.h>
int main()
{
    key_t k = getKey(); 
    printf("key: 0x%x\n", k); // key
    int shmid = createShm(k);
    printf("shmid: %d\n", shmid); //shmid 
    
    sleep(5);
    char *start = (char*)attachShm(shmid);
    printf("attach success, address start: %p\n", start);
    
    // 输出
    while(true)
    {
        printf("client say : %s\n", start);
        sleep(1);
    }
    // 去关联
    detachShm(start);
    sleep(10);
    //删除共享内存
    delShm(shmid);
    return 0;
}

解释：首先创建key值，然后创建共享内存，然后将进程与共享内存相关联，然后将从共享内存得到的数据输出

8.创建共享内存通信-写入端

shm_client.cpp

#include "comm.hpp"
#include <unistd.h>

int main()
{
    key_t k = getKey(); 
    printf("key: 0x%x\n", k);
    int shmid = getShm(k);
    printf("shmid: %d\n", shmid);

    char *start = (char*)attachShm(shmid);
    printf("attach success, address start: %p\n", start);

    const char* message = "hello server, 我是另一个进程，正在和你通信";
    pid_t id = getpid();
    int cnt = 1;
    while(true)
    {
        sleep(5);
        snprintf(start, MAX_SIZE, "%s[pid:%d][消息编号:%d]", message, id, cnt++);
    }
    detachShm(start);
    return 0;
}

解释：

1. 首先是创建key值(由于我们封装了创建key值，创建的路径以及id都是一样的，所以本写入端进程创建的key值与读取端进程创建的key值是一样的，这也是两个进程看到同一份资源(可以是内存块)的前提条件)
2. 然后获取在读取端已经创建好的共享内存的shmid值
3. 将写入端的进程与共享内存关联
4. 将该进程的pid值、计数器、message，使用snprintf以字符串的形式输出到共享内存

上面使用的都是封装的接口，如getKey()/getShm(k)

通信输出结果：

---

共享内存的特点

优点

优点：所有进程间通信，速度是最快的
进程1向进程2传递数据，因为该内存是被双方所共享的，所以我们只要将数据写入共享内存中，对方立即就能看到，所以我们就能大大减少进程1至进程2数据拷贝的次数

面试题：同样的代码，综合考虑管道和共享内存，键盘输入和显示器输出各自有几次数据拷贝？

管道：

共享内存：

这里的场景只是单纯的收发消息，如果代码有别的输入输出还需要具体问题具体分析

缺点

这里输出从编号后缀会发现一直打印相同的消息

缺点：没有进行同步与互斥的操作，没有对数据进行保护

思考：如何实现对共享内存的保护呢？
我们可以实现两个管道与共享内存结合的方式，写端写入数据到共享内存后通过管道给读端一个标识，而读端在没有这个标识的时候就阻塞，而不是一直读取，读端读完以后给写端再发一个标识，使得写端继续写，而读端又继续阻塞。

---

共享内存的内核结构

这是呈现给用户的，大致的内核数据结构体，但是内核里面更为复杂

共享内存的属性：

struct shmid_ds {
    struct ipc_perm shm_perm;    /* Ownership and permissions */
    size_t          shm_segsz;   /* Size of segment (bytes) */
    time_t          shm_atime;   /* Last attach time */
    time_t          shm_dtime;   /* Last detach time */
    time_t          shm_ctime;   /* Last change time */
    pid_t           shm_cpid;    /* PID of creator */
    pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
    shmatt_t        shm_nattch;  /* No. of current attaches */
    ...
};
struct ipc_perm {
    key_t          __key;    /* Key supplied to shmget(2) */
    uid_t          uid;      /* Effective UID of owner */
    gid_t          gid;      /* Effective GID of owner */
    uid_t          cuid;     /* Effective UID of creator */
    gid_t          cgid;     /* Effective GID of creator */
    unsigned short mode;     /* Permissions + SHM_DEST and
                                SHM_LOCKED flags */
    unsigned short __seq;    /* Sequence number */
};

我么可以在之前读取端打印共享内存的属性以及key值：

//shm_server.cpp
while(true)
{
    // char buffer[]; read(pipefd, buffer, ...)
    printf("client say : %s\n", start);
    struct shmid_ds ds;
    shmctl(shmid, IPC_STAT, &ds);
    printf("获取属性: size: %d, pid: %d, myself: %d, key: 0x%x",\
            ds.shm_segsz, ds.shm_cpid, getpid(), ds.shm_perm.__key);
    sleep(1);
}

---

如有错误或者不清楚的地方欢迎私信或者评论指出🚀🚀