Linux进程通信之共享内存

进程间通信：IPC，Inter Process Communication

共享内存原理

进程之间通信的本质是：让不同的进程，看到同一份资源。
无论是匿名管道还是命名管道的通信，我们都是在内核空间里的缓冲区进行实现的进程通信，对于这种方式在用户输入时我们在内核空间缓冲区中进行通信，然后再写入物理内存，那么我们是否可以做到直接让进程在物理内存中进行进程间的通信呢？

每一个进程都有一个虚拟内存(地址)，他们通过页表将虚拟地址映射到物理地址上，因此我们可以让操作系统帮我们在物理内存申请一段空间，然后通过页表把这份空间映射到虚拟内存的共享区，这样我们就做到了让不同的进程看到了同一份资源。

申请共享内存函数（shmget）

shmget:shared memory get，就是获取共享内存
参数：
key：这个共享内存段名字
size：需要创建的共享内存的大小
shmflg:通过类似位图实现的多操作整数
IPC_CREAT（单独）：如果你申请的共享内存不存在，存在，就获取返回
IPC_CREAT | IPC_EXCL：如果你申请的共享内存不存在，就创建，存在，就出错返回。这是为了确保我们申请的共享内存，一定是一个新的，没有被别人使用
IPC_EXCL：不单独使用
这段共享内存的权限，千万不要忘记或上 | 权限，不然后面就会导致进程挂接不上

//申请共享内存
int shmid = shmget(key, NUM, IPC_CREAT | 0666);//返回值为共享内存标识符

返回值：
共享内存标识符

参数key

key是一个数字，这个值是随机的，关键是这个随机数在内核中具有唯一性，可以让他对不同的进程拥有唯一的标识，第一个进程创建出key之后，后面的进程只要有了这个key,就可以拿着这个key去和其它进程进行共享内存了。举个例子：这个key就相当于是一把钥匙，而这个共享内存就是一把锁，只要不同的进程拿着这个钥匙，就可以打开这个内存了。那么现在的问题是我们怎么去生成这个key值呢，又这么保证它在内核中具有唯一性呢？
系统中什么具有唯一性呢?对，就是路径，路径就有唯一性，因此我们可以通过一个函数把路径作为参数传给这个函数，函数根据一定的算法帮助我们生成这个key。
库里面给我们提供了生成key的函数：ftok()

参数：
pathname：文件路径
proj_id：项目id，我们给定的一个int值，目的就是为了和文件路径一起通过一系列的算法生成一个唯一key值
作用：ftok函数通过给的路径和int值就可以帮我们生成一个在内核中具有唯一性的值。
返回值：

成功返回key，失败返回-1并设置错误码
key存在哪里呢？系统中一定有很多的共享内存，操作系统要想把他们管理起来，就要先描述再组织，因此key一定被存在共享内存的描述对象中。

生成key值示例

#include 
#include 
#include 

using namespace std;

#define PATHNAME "./common.cc" 
#define PROJ_ID 0x8888

int main()
{
    key_t key = ftok(PATHNAME, PROJ_ID);
    if(key == -1)
    {
        perror("ftok error");
        exit(0);
    }
    cout << key << endl;
    return 0;
}

所给的路径，一般是当前文件的路径，当然也可以给其他文件的，但为了保证唯一性我们一般在哪个路径下生成key就使用哪个路径，但前提是所给的文件路径一定是存在的，如果不存在就会生成失败。

申请共享内存

//申请共享内存，方式1
int shmid = shmget(key, 1024, IPC_CREAT 0666);
//申请共享内存，方式2
int shmid = shmget(key, 1024, IPC_CREAT|IPC_EXCL 0666);

问题：我们绕了一大圈生成的这个shmid和key都是具有唯一性的，那么我们为什么不直接用key呢？非要再去通过给shmget函数传key生成呢？
key是用于在操作系统内标定唯一性，而shmid是共享内存标识符，只存在于我们的进程内，用来表示资源的唯一性

共享内存的大小一般是4096（4KB）的整数倍,虽然我们这里申请的是1024，其实系统给我们的就是4096，因为操作系统是按4KB为单位对我们进行分配的，需要注意的是我们只能用1024，多给的我们不可以使用，用了就是越界可能会出现错误

挂接到进程地址空间函数(shmat)

shmat：shared memory attach
返回值为挂接到虚拟地址中的哪个位置
上面我们只是在物理内存中申请了一份共享内存，但是我们还要去把该共享内存挂接到进程地址空间的共享区中，如何做到呢？通过shmat函数来实现

参数：
shmid：就是申请共享内存函数shmget的返回值，共享内存标识符
shmaddr:让申请的共享内存挂到共享区的哪一个位置(地址)，设置成nullptr就是让系统进行决定
shmflg：进程以什么方式去挂接这个共享内存
shmaddr为NULL，核心自动选择一个地址
shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr - (shmaddr % SHMLBA)
shmflg=SHM_RDONLY，表示连接操作用来只读共享内存
返回值：返回一个void类型的指针，指向在物理内存中申请的共享内存在虚拟地址中共享内存的起始地址
共享内存：指在物理内存中申请的共享内存
共享区：指在虚拟内存中的共享区域

去关联函数(shmdt)

dt：delete touch
给虚拟内存共享区挂接的物理内存，如果进程结束，系统会自动取消关联，但是我们现在不想等到进程结束，想要在进程还在运行时就去关联，怎么做呢？
通过函数shmdt()就可以做到去关联

参数：
const void* shmaddr:就是在物理内存申请的共享内存挂接到共享区的起始地址，也就是函数shmat的返回值。
返回值：
成功返回0，失败返回-1，并设置错误码
注意：将共享内存段与当前进程脱离不等于删除共享内存段。

//去关联
shmdt(shmaddr);

控制共享内存(shmctl)

参数：
shmid：共享内存标识符，就是我们通过shmget函数得到的返回值。
cmd：控制这个函数去做什么
buf：指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值：
成功返回0，失败返回-1
其中参数cmd有三个取值，如下：

IPC_STAT

用于获取管理该共享内存结构中的数据，这个共享内存的key值，关联个数等数据

struct shmid_ds shmds;
shmctl(shmid, IPC_STAT, &shmds);
cout << "shm size: " << shmds.shm_segsz << endl;
cout << "shm nattch: " << shmds.shm_nattch << endl;
printf("shm key: 0x%x\n",  shmds.shm_perm.__key);
cout << "shm mode: " << shmds.shm_perm.mode << endl;

IPC_RMID

删除共享内存选项
shmdt函数只是把进程和该共享内存的关系从也表中删除从而取消关联，但是我们在物理内存中申请的共享内存并没有被释放，因此我们可以通过shmctl来释放对应的共享内存

ipcs

如果不通过shmctl来释放对应的共享内存，那么即使进程结束，该共享内存仍然是被占用的，因此我们可以手动的来释放该共享内存，操作如下：


此时只是去关联了，但是该共享内存仍然被占用没有被释放
通过ipcrm -m选项 + 对应的共享内存标识符来释放该共享内存

其余进程获取该共享内存

只需要创建一次共享内存，其余的进程只需拿着这个共享内存的标识符就可以得到这个共享内存了

#include 
#include 
#include 
#include 
#include 

#include "log.hpp"

using namespace std;

#define PATHNAME "/home/Linux3" 
#define PROJ_ID 0x6666
#define NUM 1024

key_t GetKey()
{
    //生成参数唯一key值
    key_t key = ftok(PATHNAME, PROJ_ID);
    if(key == -1)
    {
        perror("ftok error");
        exit(0);
    }
    return key;
}


int GetShareMemHelper(int flag)
{
    key_t key = GetKey();
    int shmid = shmget(key, NUM, flag);//返回值为共享内存标识符
    return shmid;
}

//创建第一个共享内存
int CreatShm()
{
    return GetShareMemHelper(IPC_CREAT |IPC_EXCL | 0666);
}

//获取已经创建好的共享内存
int GetShm()
{
    return GetShareMemHelper(IPC_CREAT);
}

#include "common.hpp"

int main()
{
    int shmid = GetShm();//自定义函数，用于获取已经创建好的共享内存
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    sleep(5);
    shmdt(shmaddr);
    sleep(2);
    shmctl(shmid, IPC_RMID, nullptr);
    return 0;
}

进程间通信

此时我们就可以向该共享内存写入了，而不是先写入缓冲区，再讲缓冲区数据拷贝到内存，其它进程就直接从该共享内存进行读取就可以了。
但是此时会有一个问题，就是共享内存对于不同进程而言不是同步的，即写进程还没写，读进程就从共享内存中读，此时读到的为空，或者上次的，就一直在那打印，因此我们要让进程同步，等写进程写入了，读进程才开始读，这里举个例子，我们可以通过管道来实现进程同步，因为read函数，如果没有读取到就会一直等待

char c = 'c';
while(1)
{
   fgets(shmaddr, 1024, stdin);
   write(fd, &c, 1);//向命名管道写入信息，用来通知读进程可以从共享内存中读取了//通过命名管道使得进程a,b同步
 }

Init init;
int fd = open(FIFO_FILE, O_RDONLY);
char c;
while (1)
{
    ssize_t n = read(fd, &c, 1);//等待通知信息，如果没有就退出
    if(n <= 0)
    {
        break;
    }
    cout << shmaddr;
}

创建一个管道，当向共享内存写入时，该进程通过write函数向管道中写入数据，对于读进程如果一直没有read到，就会一直等待，当读到了才会向下执行代码，这里管道的作用就是为了实现进程同步。