共享内存

原理与概念

两个进程的PCB创建虚拟地址空间然后映射到物理内存中，每个进程因为是独立的，所以在物理内存中的地址也不同。
那么共享内存是怎么做到的呢？
首先先在物理内存中申请一块内存。
然后讲这块内存通过页表映射分别映射到这两个进程的虚拟地址空间内，让这两个进程都能看到这块内存。(这里也称为进程和共享内存挂接)
最后如果不想通信了：

取消进程和内存的映射关系（去关联）
释放内存（释放共享内存）

理解：

a.这里和原本C语言当中的maclloc函数开辟空间不同，我们的目的是要让两个进程同时看到这块内存。
b.进程通信的这个申请一块共享内存是专门设计出来的，用来IPC。
c.共享内存是一种通信的方式，所有想通信的进程都可以用。
d.OS一定可能会存在很多的共享内存。

概念就是：通过让不同进程看到同一个内存块的方式就叫做共享内存。

函数接口的介绍与使用

shmget

创建共享内存接口：

首先来看第三个参数：

这里是通过位图的方式（二进制标志位）传参。

IPC_CREAT 如果不存在，创建，如果存在，就获取共享内存的位置。
IPC_EXCL 这个选项无法单独使用，必须结合IPC_CREAT使用，一起使用代表的含义是，如果不存在就创建，存在就会返回错误。（也就是说如果创建成功，他一定是一个新的共享内存——shm）

第二个参数是创建shm的大小。

返回值：
如果成功就返回一个共享内存的合法标识符，失败就返回-1。（这个和文件操作符完全不同，不是一个体系）

第一个参数：
这个是让多个进程看到同一份shm的关键。能进行唯一标识。
这个值是怎么来的呢？
用这个函数生成：

将一个合法路径（字符串）和字符数据通过某种算法组合来进行计算出key值，然后返回key。
失败了返回-1。
那么，怎么样才能让两个进程看到同一份共享内存呢？
在两个进程中如果传入到ftok中的两个参数相同，返回的key也相同，其中一个进程通过shmget接口创建共享内存，另一个接口通过shmget接口接收共享内存的位置，这样两个进程就能看到同一份资源了。

我们要利用接口让两个进程实现通信，首先创建两个.cc的文件，一个头文件.hpp。

因为两个进程都要创建/获取共享内存，所以获取key等等操作在头文件更方便。

#ifndef _COMM_HPP_
#define _COMM_HPP_

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

#define PATHNAME "."//ftok的第一个参数,是一个合法路径
#define PROJ_IO 0X666//ftok的第二个参数

key_t getkey()
{
    key_t k = ftok(PATHNAME, PROJ_IO);
    if(k < 0)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(1);
    }
    return k;
}

#endif

然后来测试一下这个函数：
两个进程都调用这个函数：

#include"shm.hpp"
int main()
{
    key_t k = getkey();
    printf("0x%x\n",k);
    return 0;
}

运行之后我们发现两个进程打印的结果key值都是相同的。

key_t的本质就是一个32位的整数。

然后再用shmget去创建和获取共享内存。

int getshmhelper(key_t k, int flags)
{
    int shmid = shmget(k, MAXSIZE, 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);//没有创建，有就报错，这里创建内存需要给对应的权限
}

我们让server去创建一个共享内存，client去拿共享内存中的数据。




这里再次创建共享内存会报错。

那么key的意义是什么呢？
首先清楚，OS一定可能会存在很多共享内存，并且本质就是申请一块空间，能进行唯一性标识最重要。
之前的C语言，malloc开辟n大小的空间的时候，释放时并不需要告诉他释放多大，自己就知道释放掉n个大小的内存，其实这一块内存中OS也要对这块中间做管理，申请了n个大小，并不代表就是n个，因为里面还有对这块内存的属性和数据左储存，比如大小，释放的时候就回去找这个大小。
这里共享内存也是一样的，OS要先描述再组织，才能进行管理，每次申请一块共享内存，OS还会给这块共享内存申请一个数据结构对象。
所以：共享内存 = 物理内存快 + 共享内存的相关属性
OS管理的是对这个共享内存的数据结构对象做管理的。

那么在创建共享内存的时候，如何保证共享内存在OS中是唯一的呢？答案就是key。
key就像餐厅当中的桌号一样，每个都具有唯一性。

其中一个进程创建共享内存，这块区域中有key值，只要另一个进程也看到同一个key就说明能看到同一块内存。

那么怎么找到key 的位置呢？就在共享内存中的数据结构中。
struct shm
{
key_t k;
}
也就是说ftok函数返回的key值其实就是赋值给共享内存数据结构中的key值。
这就是创建key的含义，key是要通过shmget设置进入共享内存属性中的，用来表示该共享内存在内核中的唯一性。

那么用来接收shmget返回值的变量有什么意义呢？
比如说，我们在企业有自己的员工号，企业扩大的时候，变动的是员工号，并不影响我们的身份证号，这时一种解耦的体现。
用来接收shmget返回值的变量和key值互相不干扰。
就像钥匙和锁一样。（fd与inode也是相同的道理）

那么如何查看IPC资源呢？
首先上面的代码在创建共享内存的时候，明明进程已经结束了，但还显示这个资源已被占用，因为共享内存是OS级的，他的生命周期是和OS相同的，要等OS的关机才会释放掉。
这里用 ipcs -m 查看共享内存。

想删除这块共享内存要用 ipcrm -m shmid

这种方法不太好，所以提供了另一个接口。

shmctl

第一个参数就是上面接受创建共享内存函数的返回值，第二个参数是选项，用来控制这个函数做什么，第三个参数是一个数据结构，就是下面的那个：

返回值是shmid，失败返回-1。

这个选项就是删除掉这段共享内存。

void delshm(int shmid)
{
    if(shmctl(shmid, IPC_RMID, nullptr) == -1)
    {
        std::cerr << errno << ":" << strerror(shmid) << std::endl;
        exit(3);
    }
}

这里谁创建的谁进行删除就可以了。


现在还差一步让两个进程与这个共享内存关联。

shmat

第一个参数是想和哪一个共享内存关联，第二个参数是想把这个共享内存映射到地址空间的哪个地方（不常用），第三个权限是读写权限（一般设置为0）。
返回值是将映射到虚拟地址空间的起始地址位置返回。（等价于C语言的malloc）
失败返回-1。

void* attachshm(int shmid)
{
    void* p = shmat(shmid, nullptr, 0);
    if((long long)p == -1L)//因为linux系统是64位，一个地址是8个字节，所以要变成8个字节大小的数据类型做对比
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(4);
    }
    return p;
}

这里就代表挂接成功了，这个共享内存挂接了一个进程。
那么如何去关联呢？

shmdt

其实就是调用去卸载当前进程共享内存的地虚拟地址空间，参数就是shmat的返回值。
返回值成功是0，错误是-1.

void detachshm(void* p)
{
    if(shmdt(p) == -1)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
    }
}

然后完善一下另一个文件中的代码：

这一份不需要他释放掉共享内存。

这里让server多休息一会。

通信

然后来完善通信的一下代码：

#ifndef _COMM_HPP_
#define _COMM_HPP_

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

#define PATHNAME "."//ftok的第一个参数,是一个合法路径
#define PROJ_IO 0X666//ftok的第二个参数
#define MAX_SIZE 4096//共享内存的大小

key_t getkey()
{
    key_t k = ftok(PATHNAME, PROJ_IO);
    if(k < 0)
    {
        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);//没有创建，有就报错,这里创建内存需要给对应的权限
}
void delshm(int shmid)
{
    if(shmctl(shmid, IPC_RMID, nullptr) == -1)
    {
        std::cerr << errno << ":" << strerror(shmid) << std::endl;
        exit(3);
    }
}
void* attachshm(int shmid)
{
    void* p = shmat(shmid, nullptr, 0);
    if((long long)p == -1L)//因为linux系统是64位，一个地址是8个字节，所以要变成8个字节大小的数据类型做对比
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(4);
    }
    return p;
}
void detachshm(void* p)
{
    if(shmdt(p) == -1)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
    }
}

#endif

#include"shm.hpp"
int main()
{
    key_t k = getkey();
    printf("0x%x\n",k);
    int shmid = getshm(k);//接收共享内存
    printf("shmid : %d\n", shmid);

    char* p = (char*)attachshm(shmid);//关联
    printf("attach sucess, address p: %p\n",p);

    //使用
    const char* str = "hello server, 我是另一个进程，我在和你通信";
    pid_t id = getpid();
    int count = 0;
    while(true)
    {
        sleep(1);
        snprintf(p, MAX_SIZE, "%S[pid:%d][消息编号:%d]", str, id, count++);
    }

    detachshm(p);//去关联

    return 0;
}

#include"shm.hpp"
int main()
{
    key_t k = getkey();
    printf("0x%x\n",k);
    int shmid = createshm(k);//创建共享内存
    printf("shmid : %d\n", shmid);
    char* p = (char*)attachshm(shmid);//关联
    printf("attach sucess, address p: %p\n",p);

    //使用
    while(true)
    {
        printf("client say: %s\n",p);
        sleep(1);
    }

    detachshm(p);//去关联
    sleep(10);

    delshm(shmid);//删除共享内存
    return 0;
}

共享内存的特点

优点：是所有进程通信中速度最快的，并且不像原来管道的那种需要定义一个buffer来储存数据，减少拷贝次数。
相比较于管道，数据传输进管道需要拷贝一次，数据传出数据需要拷贝一次，而共享内存不用。
共享内存的缺点：
不给我们进行同步和互斥的操作，也就是没有对数据进行任何保护。没任何规定，没有写也读，写到一半也会去读，这种情况就要用信号量去处理了。
那么如何实现呢？

写完，通知读端读取
没通知的时候让server等待

如果不通过信号量，可以用两个匿名管道进行操作，思路：

两个进程写和读之前遵守管道的规则，没有不能读，满了不能写等等。

共享内存的内核结构

之前在介绍shmctl接口中，文档已经显示了共享内存的数据结构了：

那么我们怎么拿到这些属性呢？
通过这个选项，来拷贝内核的数据结构然后传出来。

其中key是在第一个数据结构的第一个成员的数据结构当中，这相当于又做了一层封装。
这里还有一个重点，如果我们将共享内存的大小改成4097会怎么样？
那么显示这块内存的数据结构是4097的大小，但是实际物理内存以你为是按照每次最少开辟4KB大小算的（内存划分内存块的基本单位），所以一般都是开辟4KB的整数倍，这里显示是4097只是因为他是数据结构，实际上多出了4KB-1的空间大小，内核这里会给我们向上取整。
这里要按照数据结构的大小才能算是我们能用的大小，这里内核给的和能用多少是两码事。

system V消息队列（了解）

消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法。
每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值特性方面。
IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内核。

用这个接口可以获取消息队列：

返回值是创建好的消息队列的标识符。
下面这个是消除消息队列。


这是消息队列的数据结构。
也可以理解为是一个链式结构。
想查看消息队列用：ipcs -q

system V——初识信号量

想查看信号量用：ipcs -s

信号量的预备概念

在了解信号量之前先了解这些概念：
信号量是什么？本质是一个计数器，通常用来表示公共资源中，资源数量的多少问题的。
公共资源：被多个进程可以同时访问的资源。
访问没有保护的公共资源：会导致数据不一致的问题，比如正在写的时候，另一个进程已经读了。
我们未来将被保护起来的公共资源：临界资源，有大部分的资源是独立的。
资源是什么：内存，文件，网络等。只要是被使用的就算。那么如何被使用呢？一定是该进程有对应的代码来访问这部分资源，在访问的时候会被保护起来，这部分代码被称为临界区，其他没有访问这部分公共资源的叫做非临界区。
例如：

红框这里是在打印p这个共享内存的内容，这个就是临界区，其他代码就是非临界区。
那么如何保护呢？同步&&互斥：
这里先了解什么是互斥，其实就是当有两个进程想访问一分公共资源时，不能两个同时一起访问，要等一个访问完之后另一个才能进行访问。
原子性：要么不做，要么就做完。这个叫做原子性。比如，A给B微信转钱，A 转了 B 50，但是50没有发送到B的账户里面，反而A的账户扣了50，这样是很不合理的，所以这里就要用原子性，要么转钱转过去A账户扣50，要么转钱失败A账户一分都不少，只有这两种结果。

信号量和这些有什么关系呢信号量主要就是完成同步互斥和原子性的！

理解信号量

那么在深入了解一下信号量是什么，信号量虽然是一个计数器，但是不可能是一个进程的全局变量。
假设：

信号量是售票的处，他有100张票。
公共资源是电影院的座位，有100个。

那么如果我买完票了，座位号是1，我没有坐到这个位置上，但是这个位置也是属于我的。
也就是说我相当于对这个1号位置进行了预定，也就是说我们申请资源的时候要进行预定。
并且，座位只有100张，不能卖100张以上的票。

那么我们定义票数是count = 100；
卖出去一张是count–，如果if(count == 0) 就不卖了;

那么你公共资源可以分为两种：

1.作为一个整体使用。（管道）
2.划分成为一个一个的资源子部分。（食堂打饭不可能只开放一个窗口打饭，一个人打完另一个人进，这样是不行的，所以要将食堂分成多个窗口打饭）

那么如果买到票了，电影院一定让你进入，买不到票电影院不会让你进入，这就属于一种保护。
也就是对于临界资源进行的一种保护，这就是信号量。
那么信号量–叫做预定资源，++就是释放资源。

也就是说在申请公共资源的时候，所有进程都要通过信号量申请，那么前提是所有进程看到的都是同一个信号量，也就是说信号量本身就是一个公共资源，那么信号量如何确保自己的安全呢？
上面说了，- - 是预定资源++是释放资源，这些操作是让这个信号量变化的途径，这里信号量中的这两个操作是原子性的。
预定资源是P操作，释放资源是V操作。这就是PV操作。

也就是说信号量在system V版本中同时被多个进程看到，必须匹配两个操作，一个是P操作，一个是V操作。

那么如果一个信号量初始值为1是什么意思呢？
这就说明这个公共资源是一个整体资源了。
这个也叫做二元信号量，主要提供互斥作用的。

信号量的接口与结构

申请信号量。

第二个参数是申请几个信号量，第三个参数依旧是选项。
返回值是返回一个信号量的集合。
如果不想用某个信号量了，用这个接口：

第一个参数是信号量对应的id，第二个参数是信号量的下标（第九个就填9，不想填就填0），第三个参数是选项了：

很多个，不一一列举了，也可以去获取信号量的信息。
信号量的数据结构：

那么怎么对信号量进行PV操作呢？


第一个参数是指定的信号量，第二个参数是选项，1是++，-1是- -。
第三个参数是代表要第二个参数的结构体有多少个，假如说之前申请了10个信号量，那么这里填写10，然后就可以写一个第二个参数类型的数组里面有10个这种类型的数据，对这10个信号量集合做PV操作。（这就像买电影票可以买很多张不同的电影票一样）

IPC资源的组织方式

这里其实我们已经发现了，共享内存的数据结构，消息队列的数据结构，信号量的数据结构，他们的接口相似度非常高！
这就说明，他们属于system V标准的进程通信。
他们的第一个成员，全都是这一种结构：

我们可以用一个指针数组来组织这个数据结构：

我们只要将这三个不同的数据结构中第一个成员放进这个数组中就可以了。

因为，结构体第一个成员的地址是和这个结构体对象本身的地址是相同的。
也就是说如果未来想访问共享内存的数据结构，直接将perms数组中第一个元素取出来，然后强制转换成共享内存数据结构的构造体就可以了！
C++多态就是通过这个思维创建出来的！