【Linux】进程间通信之-- 共享内存与信号量的介绍（下）

前言
上一篇，我们由进程间通信，引入并讲述了管道、匿名管道和命名管道，本节，将继续学习进程间通信的另一种方式之，共享内存。还要学习几个系统调用接口，并演示两个进程通过共享内存来进行通信。。。

- 1.共享内存
- 1.1 创建共享内存
- - 1.1 ftok()创建key值
  - 1.2 shmget函数
  - 1.3 ipcs指令查看共享内存资源
  - 1.4 shmctl()接口
  - 1.5 shmat()接口
  - 1.6shmdt函数接口
  - 1.7 共享内存总结
  - 1.8 通过管道对共享内存进行控制：
- 2. 相关概念
- 3. 信号量
- - 3. 1 信号量的分类
  - 3. 2 信号量的原子性说明
  - 3. 3 信号量的规则

1.共享内存

本节讲的是system V的共享内存。

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

共享内存示意图
在这里插入图片描述

我们知道堆栈相对而生，堆从低地址向高地址生长，栈从高地址向低地址生长，而在这两块空间之间的则是共享区。
堆栈之间的区域特别大，堆栈之间的区域称为共享区，其中共享库就在这里。

共享内存的实现：

在物理空间上创建共享内存（申请一段空间）。
通过两个进程调用接口，然后物理内存中的空间映射到自己的地址空间上。

进程间通信的前提是：先让不同的进程，看到同一份资源

共享内存是一种进程间通信机制，它允许多个进程共享同一块物理内存区域（就能同时看到一份资源）。
当一个进程向共享内存写入数据时，实际上是将数据直接写入到共享内存所对应的物理内存中。
其他进程可以通过读取相同的共享内存区域来获取已写入的数据。

优点：

与其他进程间通信方式（如管道、消息队列等）不同。
共享内存避免了数据的复制和传输过程，因此具有较高的效率。
可以提供快速的数据交换，特别适用于需要频繁共享大量数据的进程间通信场景

共享内存数据结构

在这里插入图片描述

1.1 创建共享内存

共享内存=共享内存块+对应的共享内存的内核数据结构！

1.1 ftok()创建key值

共享内存存在哪里？
共享内存提供者，是操作系统
存在于内核中，内核会给我们维护共享内存的结构
操作系统也需要管理共享内存，一定是先描述，再组织
我怎么知道，这个共享内存是存在还是不存在？
需要标识共享内存的唯一性！
在内核中，让不同的进程看到同一份共享内存。。
做法是：让他们拥有同一个key即可。。

为了实现这种共享，操作系统会给每个共享内存区域分配一个唯一的key值来标识它，其他进程可以通过这个key值来访问并操作该共享内存区域。
这样就可以实现多个进程之间的数据交换和共享。

创建key值的函数：
在这里插入图片描述

返回值：key_t（其实就是int类型）成功了返回key值，失败了就返回-1。

Linux系统给定了ftok接口，将用户提供的pathname工作路径，以及proj_id项目编号转换为一个共享内存的key（其实就是int类型）
底层会将第一个参数对应路径文件的inode和指定的项目id这两个数字做组合形成一个唯一值，返回给一个key。
底层是一些列的算法设计，相当于是帮我们构建具有唯一性的数字就可以了。

1.2 shmget函数

功能：用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);
参数
key:这个共享内存段名字
size:共享内存大小（建议设置成页（4KB）的正式倍
shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的

返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1
共享内存的用户层标识符shmid，类似于曾经的fd,

操作系统和磁盘lO的基本单位大小是4KB。
从磁盘拷贝到内存是以4KB为单位拷贝的。
所以共享内存在申请大小时，也一定是4KB的整数倍。
操作系统只会按照整4KB来申请共享内存，是向上取整。

shmflg参数设置解释：

IPC_CREAT：创建共享内存，如果已经存在，就获取之，不存在就创建之。
注：可以获取成功，但是不知道这个共享内存，是本进程创建还是别的进程创建的拿过来的。
IPC_EXCL：必须配合IPC_CREAT使用（用按位或|配合使用），如果不存在指定的共享内存，创建之，如果存在了，出错返回。
注：核心作用：可以保证，如果shmget函数调用成功，一定是一个全新的share memory（共享内存）。
如果这两个选项合着一起配合使用，一起传，只要函数调用成功了，得到的一定是个全新的共享内存。
0666或权限值：指定共享内存的访问权限。这些权限值使用八进制表示，例如0666表示可读可写权限。

key参数说明：

key值得由用户来提供。
如果key值是由操作系统统一提供的话，另一个进程是无法获得共享内存的key值的。

1.3 ipcs指令查看共享内存资源

通过上述讲解，我们只要获取到唯一的key值，调用shmget函数就能获得共享内存了，创建好了我们怎样才能知道有哪些IPC资源呢。
ipcs指令的几个选项：

ipcs -c #查看消息队列/共享内存/信号量
ipcs -s #单独查看信号量
ipcs -q #单独查看消息队列
ipcs -m #单独查看共享内存

ipcrm -m 删除共享内存：

只要在指令后跟上自己要删除的共享内存的shmid值就可以了
为什么删除共享内存要用shmid而不用key呢？

key是操作系统中用来标识共享内存唯一性的，在用户层用的是shmid。
在用户层访问共享内存只能用数字shmid。

1.4 shmctl()接口

shmctl这个函数可以用于操作共享内存：

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

第二个参数解释：
IPC_STAT：用于获取共享内存段的状态信息，包括共享内存段大小、访问权限等。
IPC_SET：用于设置共享内存段的状态信息，如更改访问权限、起始地址等。
IPC_RMID：用于删除共享内存段，释放相关的资源

第三个参数：如果IPC_RMID如果被设置了，shmid_ds设置成nullptr就可以了，还有一些其他的属性设置

 shmctl(shmid, IPC_RMID, NULL)

注意：
当进程运行结束，我们的共享内存，还存在的。
需要使用shmctl( )函数手动删除。。

1.5 shmat()接口

at是attach的简写，把一个共享内存附在进程上

功能：将共享内存段连接到进程地址空间
原型
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，表示连接操作用来只读共享内存

char *addr = shmat(shmid, NULL, 0)

补充注意事项：

因为shmat函数的返回值是一个void*类型的指针，所以我们就可以像使用malloc一样的方式使来挂接共享内存了。
随后对这个共享内存的操作就像平时使用数组一样的方式来使用了。
共享内存是一种特殊的内存区域，可以由多个进程同时访问。
尽管共享内存由一个进程创建，但它并不属于任何一个特定的进程。

同样的道理另一个进程也需要挂接这个共享内存才能实现两个进程通过共享内存来进行通信.

1.6shmdt函数接口

dt是detach的简写，把一个共享内存从进程上脱离下来（去关联）。

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

1.7 共享内存总结

可以将共享内存当成一个大字符串
只要是通信双方使用shm，一方直接向共享内存中写入数据，另一方，就可以立马看到。共享内存是所有进程间通信（IPC)里速度最快的！，不需要过多的拷贝
共享内存缺乏访问控制！会带来并发问题。因为有临界区资源问题，要做到同步

管道通信过程演示：

管道的通信，使用了read/write函数，会有访问控制，一共经历4次拷贝。。

在这里插入图片描述

1.8 通过管道对共享内存进行控制：

Log.hpp：

#pragma once

#include <iostream>
#include <ctime>

std::ostream &Log()
{
    std::cout << "For Debug | " << "timestamp: " << (uint64_t)time(nullptr) << " | ";
    return std::cout;
}

Comm.hpp：

#pragma once

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <cstdlib>
#include <cassert>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include "Log.hpp"

using namespace std;

#define PATH_NAME "/home/Zh_Ser/linux"
#define PROJ_ID 0x14
#define MEM_SIZE 4096

#define FIFO_FILE "./.fifo"

// hpp是将头文件和源文件写在一起的方式
// 函数的定义可以放在里面，一般在开源的项目里用

key_t CreateKey()
{
    key_t key = ftok(PATH_NAME, PROJ_ID);
    if (key < 0)
    {
        cerr << "ftok: " << strerror(errno) << endl;
        exit(1);
    }
    return key;
}

// 创建命名管道
void CreatFifo()
{
    umask(0);
    if (mkfifo(FIFO_FILE, 0666) < 0)
    {
        Log() << strerror(errno) << endl;
        exit(2);
    }
}

#define READER O_RDONLY
#define WRITER O_WRONLY

int Open(const string& filename, int flags)
{
    return open(filename.c_str(), flags);
}

int Wait(int fd)
{
    uint32_t values = 0;
    ssize_t s = read(fd, &values, sizeof(values));
    
    return s;
}

void Signal(int fd)
{
    uint32_t cmd = 1;
    int s = write(fd, &cmd, sizeof(cmd));
}

void Close(int fd, const string filename)
{
    close(fd);
    unlink(filename.c_str());
}

IpcShmClient.cpp：

#include "Comm.hpp"
#include "Log.hpp"

// 充当使用共享内存的角色
int main()
{
    int fd = Open(FIFO_FILE, WRITER);
    cout << "Client: " << fd << endl;
    // 创建相同的key值
    key_t key = CreateKey();
    Log() << "key: " << key << endl;

    // 等待Server端先创建共享内存
    sleep(1);
    
    // 获取共享内存
    int shmid = shmget(key, MEM_SIZE, IPC_CREAT);
    if (shmid < 0)
    {
        Log() << "IpcShmCli shmget: " << strerror(errno) << endl;
        return 2;
    }

    // 挂接
    char* addr= (char*)shmat(shmid, nullptr, 0);

    // sleep(5);
    // 用它

    // 用共享内存，竟然没有使用任何系统调用接口
    // 直接向str空间写入
    while (true)
    {
        printf("Please Enter# ");
        fflush(stdout);
        // 往共享内存写数据

        ssize_t s = read(0, addr, MEM_SIZE);
        if (s > 0)
        {
            str[s] = '\0';
        }
        Signal(fd);
    }

    // 去关联
    shmdt(addr);
    
    // 不需要删除
    return 0;
}

IpcShmServer.cpp

#include "Comm.hpp"
#include "Log.hpp"

// 创建全新的共享内存
const int flags = IPC_CREAT | IPC_EXCL;

// 充当创建共享内存的角色
int main()
{
    // 创建管道
    CreatFifo();
    int fd = Open(FIFO_FILE, READER);
    cout << "Server: " << fd << endl;
    assert(fd >= 0);

    // 创建Key
    key_t key = CreateKey();
    Log() << "key: " << key << endl;

    Log() << "create share memory begin" << endl;

    int shmid = shmget(key, MEM_SIZE, flags | 0666);
    if (shmid < 0)
    {
        Log() << "IpcShmSer shmget: " << strerror(errno) << endl;
        return 2;
    }
    Log() << "create shm success, shmid: " << shmid << endl;

    // 1. 将共享内存和自己的进程产生关联attch
    char* addr= (char*)shmat(shmid, nullptr, 0);
    Log() << "attach shm: " << shmid << "success" << endl;

    // 用它
    // 服务器端直接用
    while (true)
    {
        sleep(1);
        // 在管道当中等，让读端进行等待
        if (Wait(fd) <= 0) break;
        
        // 从共享内存里读数据
        printf("%s\n", addr);
    }
    
    // **2. 去关联shmdt的返回值就是shmat的返回值**
    shmdt(addr);
    Log() << "detach shm: " << shmid << "success" << endl;

    // 删除
    shmctl(shmid, IPC_RMID, nullptr);

    Log() << "delete shm: " << shmid << "success" << endl;

    Close(fd, FIFO_FILE);
    
    return 0;
}