【Linux】进程间通信之共享内存/消息队列/信号量

一、共享内存的概念及原理

共享内存是通过让不同的进程看到同一个内存块的方式。

我们知道，每一个进程都会有对应的PCB-task_struct ，独立的进程地址空间，然后通过页表将地址映射到物理内存中。此时我们就可以让OS在内存中申请一块空间，然后将创建好的内存空间映射到进程的地址空间中，两个需要进行通信的进程经过映射之后就看到了同一块内存空间，在未来两个进程不想进行通信之后，取消进程和内存的映射关系—去关联，然后释放内存即可。

我们需要注意的是，进程地址空间，是专门设计的，用来IPC，共享内存是一种通信方式，所以想通信的进程，都可以使用，那么OS中一定会同时存在很多的共享内存。

二、共享内存相关接口说明

1.shmget函数

功能：用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);
头文件
#include <sys/ipc.h>
#include <sys/shm.h>
参数
key:这个共享内存段名字
size:共享内存大小
shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
其中最常用的两个标志位：
IPC_CREAT:如果文件不存在就创建，存在就获取
IPC_EXCL:无法单独使用，IPC_CREAT | IPC_EXCL，如果不存在就创建，如果存在就出错返回，这样就保证如果创建成功，一定是一个新的shm
返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

2.ftok函数

功能；获取key
原型
key_t ftok(const char *pathname, int proj_id);
头文件
#include <sys/types.h>
#include <sys/ipc.h>
参数
pathname:文件名
proj_id:非0整数，用于形成key
返回值:成功返回key,失败返回-1，错误码被设置

我们在申请内存使用malloc函数需要告诉要申请多大的空间，而释放的时候只需要告诉内存的起始地址即可，那么操作系统是如何知道我们申请了多大的内存呢，实际上，我们在申请内存的时候，OS为我们提供了申请的空间和该空间的属性，如大小等等。一个程序多次申请空间，那么操作系统就需要将这些空间管理起来，管理的方法是先描述再组织，描述的对象的就是这些空间的属性。共享内存也是如此，OS先描述再组织，所以共享内存=共享内存块+共享内存的相关属性。那么我们创建共享内存的时候，如何保证共享内存在系统中是唯一的，答案是通过key来进行唯一标识，那么key在哪呢，key在共享内存的属性struct shm{key_t key;};中

3.shmat函数

功能：将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
头文件
#include <sys/types.h>
#include <sys/shm.h>
参数
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，表示连接操作用来只读共享内存

4.shmdt函数

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

5.shmctl函数

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

三、用共享内存实现server&client通信

1.shm_server.cc

#include "comm.hpp"

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

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

    while (true)
    {
        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);
    }

    // 去关联
    detachShm(start);

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

2.shm_client.cc

#include "comm.hpp"

int main()
{
    key_t key = getkey();
    printf("key:0x%x\n", key);
    int shmid = getShm(key);
    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;
    // char buffer[1024];
    while (true)
    {
        snprintf(start, MAX_SIZE, "%s[pid:%d][消息编号%d]", message, id, cnt++);
        // snprintf(buffer, sizeof(buffer), "%s[pid:%d][消息编号:%d]", message, id, cnt++);
        // memcpy(start, buffer, strlen(buffer)+1);
        // pid, count, message
        sleep(1);
    }

    detachShm(start);

    return 0;
}

3.comm.hpp

#ifndef __COMM_HPP_
#define __COMM_HPP_

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

#define PATHNAME "."
#define PROJ_ID 0x666

// 共享内存的大小，一般建议是4KB的整数倍
// 系统分配共享内存是以4KB为单位的！ --- 内存划分内存块的基本单位Page
#define MAX_SIZE 4096 // --- 内核给你的会向上取整， 内核给你的，和你能用的，是两码事

key_t getkey()
{
    key_t key = ftok(PATHNAME, PROJ_ID);
    if (key == -1)
    {
        std::cerr << "error" << strerror(errno) << std::endl;
        exit(1);
    }

    return key;
}

int getShmHelper(key_t key, int flags)
{
    int shmid = shmget(key, MAX_SIZE, flags);
    if (shmid < 0)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(2);
    }

    return shmid;
}

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

int createShm(key_t key)
{
    return getShmHelper(key, IPC_CREAT | IPC_EXCL | 0600);
}

void *attachShm(int shmid)
{
    void *mem = shmat(shmid, nullptr, 0);
    if ((long long)mem == -1L)
    {
        std::cerr << "shmat:" << errno << ":" << strerror(errno) << std::endl;
        exit(3);
    }

    return mem;
}

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

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

4.查看ipc资源及其特征

查看IPC资源的指令

ipcs -m/-q/-s
分别查看共享内存/消息队列/信号量
删除使用  ipcrm -m shmid

IPC资源的特征

共享内存的生命周期是随OS的，不是随进程的

我们使用ctrl C终止程序之后，第二次显示文件存在

5.共享内存的优缺点

优点：在所有进程间通信中是最快的，能大大的减少数据拷贝的次数

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到

内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据

同样的代码，如果用管道来实现，综合考虑管道和共享内存，考虑键盘输入和显示器输出，共享内存和管道各有几次数据拷贝

对于管道，我们将输入的数据线拷贝到我们自己定义的缓冲区buffer中，然后通过系统调用write写到管道中，然后通过read读到自己定义的缓冲区buffer中，然后再拷贝到显示器上，这里我们不考虑输入时从键盘到stdin的拷贝，stdout到显示器的拷贝，所以管道一共需要拷贝4次

对于共享内存，我们只需要将数据拷贝到共享内存中，然后从共享内存中拷贝到显示器上，同样这里不考虑键盘到stdin，stdout到显示器的拷贝，所以一共需要拷贝2次

缺点：不能进行同步和互斥操作，没有对数据做任何保护

6.共享内存的数据结构

struct shmid_ds {
 struct ipc_perm shm_perm; /* operation perms */
 int shm_segsz; /* size of segment (bytes) */
 __kernel_time_t shm_atime; /* last attach time */
 __kernel_time_t shm_dtime; /* last detach time */
 __kernel_time_t shm_ctime; /* last change time */
 __kernel_ipc_pid_t shm_cpid; /* pid of creator */
 __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
 unsigned short shm_nattch; /* no. of current attaches */
 unsigned short shm_unused; /* compatibility */
 void *shm_unused2; /* ditto - used by DIPC */
 void *shm_unused3; /* unused */
};

struct shmid_ds结构体中包含了struct ipc_perm结构体，其中就包含了key

四、system V消息队列

消息队列就是内核提供了队列这种数据结构用于进程间通信，两个进程可以相互通信，队列的每一个节点包含了类型标识符，表示是各自读的数据还是写的数据

消息队列的接口如下：

int msgget(key_t key, int msgflg);
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);

消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法

每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值特性方面

IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内核

这里就不做过多的介绍了，消息队列我们了解即可。

五、system V信号量

信号量本质是一个计数器，通常用来表示公共资源中，资源数量的多少问题的。公共资源是被多个进程同时可以访问的资源。访问没有保护的公共资源，那么就会导致数据不一致的问题。

我们为什么要让不同的进程看到同一份资源呢，因为我们要进行通信，进程间实现协同，但是进程具有独立性，我们让进程看到就提出一些方法，但是又引入了一些新的问题(数据不一致问题)

我们未来将被保护起来的公共资源：临界资源，大部分是独立的

资源(内存，文件，网络等)是要被使用的，如何被进程使用呢，一定是该进程有对应的代码来访问这部分临界资源，这部分代码被称为临界区，其他的代码被称为非临界区

我们如何对数据进行保护呢：同步和互斥。互斥就是我在访问临界资源的时候，其他人不能够进行访问

原子性：要么不做，要做就做完，只有两态

为什么要有信号量呢？

我们举一个例子，我们在电影院看电影，我们不是只有坐在电影院对应的座位上的时候这个座位CIA属于我，而是我们买票的时候，就对放映厅中的座位进行了预定，此时座位就已经属于我们了。即当我们想要某种资源的时候，我们可以进行预定。假如放映厅有100个座位，那么电影院会不会卖出101张票呢，答案是不会，我们该如何做到呢。我们可以定义一个信号量，初始值为100，卖出一张票就-1，为0的时候就停止售票

信号量sem=100
sem--;//预定资源   --- P操作
访问公共资源
sem++;//释放公共资源  --- V操作

所以的进程在访问公共资源之前，都必须先申请sem信号量 ->先申请信号量的前提，是所有进程都必须先看到同一个信号量 ->信号量本身就是公共资源 -> 信号量本身也要保证自身的安全，–，++ ->信号量必须保证自身操作的安全性，–，++操作是原子

共享资源可以被当做一个整体资源，也可以被划分为一个一个资源的子部分

当一个信号量的初始值为1的时候，那么该信号量我们称为二元信号量，具有互斥的功能

由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥

系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源。

在进程中涉及到互斥资源的程序段叫临界区

IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内核

六、IPC资源的组织方式

我们可以发现system V三种方式的数据结构如下：

共享内存：

消息队列：

信号量：

我们发现，他们的接口的相似度非常高，这样说明他们都是system V方式的进程间通信

我们可以创建一个struct ipc_perm *perms[]的数组，用于存放struct ipc_perm

我们创建一个共享内存数据结构的对象 struct shmid_ds myshm，然后perms[0] = &myshm.shm_perm

创建一个消息队列的数据结构对象 struct msqid_ds mymsg, prems[1] = &mymsg.msg_perm

然后我们在获取共享内存的属性的时候，就可以通过如下的方式进行获取

(struct shmid_ds*)perms[0] ->其他属性

这是因为一个结构体的第一个成员的地址，在数字上，和结构体对象本身的地址数字是相等的

这种方式向C++的多态一样，数组中的对象为基类，具体的对象(共享内存，消息队列，信号量)为子类