Linux：IPC - System V

Linux：IPC - System V

• • [共享内存 shm](#共享内存 shm)
  • • 创建共享内存
    • • shmget
      • shmctl
      • ftok
    • 挂接共享内存
    • • shmat
      • shmdt
    • shm特性
  • [消息队列 msg](#消息队列 msg)
  • • msgget
    • msgctl
    • msgsnd
    • msgrcv
  • [信号量 sem](#信号量 sem)
  • [System V 管理机制](#System V 管理机制)

---

System V IPC 是Linux系统中一种重要的进程间通信机制，它主要包括共享内存 shm，消息队列 msg，信号量 sem。本博客讲解基于System V的进程间通信。

---

共享内存 shm

共享内存，顾名思义就是一块被多个进程共享的内存，由于进程间具有独立性，毫无疑问这一块内存不应该由某一个进程进行开辟，而是由操作系统亲自开辟。

如上图，共享内存会被进程的页表直接映射到自己的进程地址空间的共享区，从而通过地址空间直接对内存操作，这就是多个进程共享一块内存的基本原理。

那么我们现在就来看看如何创建出一个共享内存shm：

---

创建共享内存

shmget

shmget 函数是 shm 中用于创建或获取共享内存段的函数。需要头文件<sys/ipc.h>和<sys/shm.h>函数原型如下：

int shmget(key_t key，size_t size，int shmflg)；

返回值：

shmget返回一个整型，这个整型叫做shmid，用于标识唯一的shm。

1. key： 用于标识要创建或获取的共享内存段

key是System V的唯一标识符，注意不是shm的，而是所有System V的，你可以通过一个key值来标识任意一个system V。

• 标识唯一的shm是shmid
• 标识唯一的system V是key

2. size： 指定要创建的共享内存段的大小，单位为字节

注意：共享内存以4 kb为基本单位开辟内存，也就是4096 byte，因此开辟shm的时候，这个参数最好设置为4096的倍数。哪怕你只申请了1 byte的内存，实际上还是会开辟4096 byte大小的空间。

3. shmflg： 用于指定共享内存段的访问权限和其他选项

这是一个用于控制共享内存的开辟方式，以及各个属性的选项，本质是一个位图。

• IPC_CREAT： 如果指定的key不存在，则创建一个新的共享内存段，如果已经存在，则直接获得原先的共享内存

• IPC_EXCL： 如果指定的key已经存在，则创建失败

要注意IPC_EXCL只能配合IPC_CREAT一起使用，不能单独使用IPC_EXCL。

另外的，共享内存也可以设置读写权限，直接将权限值的八进制按位或到第三个参数中即可。

示例：

int main()
{
    int shmid = shmget(1, 4096, IPC_CREAT | IPC_EXCL | 0666);

    return 0;
}

以上函数中，就是一个简单的创建共享内存的过程：

• 第一个参数1：即这个共享内存的system V标识符key = 1；
• 第二个参数传入4096：即开辟的共享内存大小为4096 byte；
• 第三个参数为IPC_CREAT | IPC_EXCL | 0666：如果当前的key不存在，则创建对应的共享内存，共享内存的初始权限为0666，如果存在，则创建失败。

那么我们要如何知道成功创建了一个共享内存呢？

通过ipcs指令，可以看当前所有的system V的总体情况：

如果只想看共享内存，则输入ipcs -m：

可以看到，我们创建了一个共享内存，key = 0x00000001，shmid = 2，拥有者onwer = box-he，初始权限perm = 666，大小bytes = 4096。

那么现在有一个问题就是：我们的进程已经结束了，但是进程创建的共享内存还在！

也就是说，共享内存如果不主动释放，那么共享内存就会一直存在，除非重启操作系统。这个特性叫做：共享内存的生命周期随内核。

如果想要删除一个共享内存，有两种方式：通过指令 / 通过接口。

通过ipcrm -m xxx，可以删除shmid为xxx的共享内存。

示例：

一开始存在一个shmid = 2的共享内存，通过指令ipcrm -m 2，就可以删除这个共享内存了。

如果想要通过接口删除共享内存，则通过shmctl接口。

---

shmctl

shmctl 用于控制共享内存的各种属性。

其包含以下功能：

• 获取共享内存段的状态信息
• 修改共享内存段的属性
• 删除共享内存段

shmctl包含在头文件<sys/ipc.h>和<sys/shm.h>中，函数原型如下：

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

返回值：

• 成功时返回 0
• 失败时返回 -1，并设置 errno 变量

参数如下：

• shmid：要操作的共享内存段的标识符
• cmd：要执行的操作,可以是以下值之一：
  • IPC_STAT：获取共享内存段的状态信息
  • IPC_SET：设置共享内存段的某些属性
  • IPC_RMID：删除共享内存段
• buf：指向 shmid_ds 结构体的指针，用于存储或设置共享内存段的属性

在讲解以上三种模式前，要先介绍一下一个结构体shmid_ds。

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 */
    ...
};

shmid_ds 是一个Linux中给共享内存定义的结构体，这个结构体用于存储一个共享内存的基本信息。

当第二个参数cmd为IPC_STAT，此时就可以获取一个共享内存的基本信息。

示例：

int main()
{
    int id = shmget(1, 4096, IPC_CREAT | IPC_EXCL | 0666);

    struct shmid_ds shm;

    shmctl(id, IPC_STAT, &shm);

    cout << "atime:" << shm.shm_atime << endl;
    cout << "ctime:" << shm.shm_ctime << endl;
    cout << "cpid:" << shm.shm_cpid << endl;

    return 0;
}

输出结果：

以上示例中，通过一个struct shmid_ds类型的结构体变量shm，通过调用shmctl(id, IPC_STAT, &shm);获取到了这个共享内存的相关信息。

其中shmctl(id, IPC_STAT, &shm);

第一个参数id：要控制的共享内存的shmid

第二个参数IPC_STAT：表示当前shmctl的作用是获取共享内存相关信息

第三个参数&shm：表示获取到的信息存入变量shm中

当第二个参数cmd为IPC_SET，就可以设置共享内存的某些属性

示例：

int main()
{
    int id = shmget(1, 4096, IPC_CREAT | IPC_EXCL | 0666);

    struct shmid_ds shm;

    shmctl(id, IPC_STAT, &shm);

    cout << "atime:" << shm.shm_atime << endl;

    shm.shm_atime = 1 ;
	
	//修改shm信息
    shmctl(id, IPC_SET, &shm);

	//重新获取shm信息
    shmctl(id, IPC_STAT, &shm);

    cout << "atime:" << shm.shm_atime << endl;

    return 0;
}

一开始通过shmctl(id, IPC_STAT, &shm);把共享内存的相关信息存储到了结构体shm中，然后把结构体的shm_atime 成员设置为1。

再通过shmctl(id, IPC_SET, &shm);把共享内存的信息设置成和shm一致，此时第二个参数为IPC_SET。

第三次调用shmctl(id, IPC_STAT, &shm);，此时再把共享内存的信息同步到shm中，最后输出shm的shm_atime 成员。

输出结果：

可以看到，当第二个参数为IPC_SET时，可以修改共享内存的相关属性。

当第二个参数为IPC_RMID，表示要删除共享内存段

此时由于我们要删除共享内存，第三个参数就用不上了，此时设置为空指针即可。

示例：

int main()
{
    shmctl(3, IPC_RMID, nullptr);

    return 0;
}

以上代码中shmctl(3, IPC_RMID, nullptr);就表示要删除shmid = 3的共享内存。

输出结果：

一开始存在一个shmid = 3 的共享内存，经过./test.exe后，这个共享内存就被删除了，也就是执行了shmctl(3, IPC_RMID, nullptr);。

最后再看一次第二个参数的作用：

• cmd：要执行的操作,可以是以下值之一：
  • IPC_STAT：获取共享内存段的状态信息
  • IPC_SET：设置共享内存段的某些属性
  • IPC_RMID：删除共享内存段

现在应该可以理解三种情况的作用了。

---

ftok

创建之前所有示例中，通过shmget创建共享内存时，第一个参数key我都设置为了1，但其实这是非常不符合规范的。操作系统中存在非常多的进程，如果多个进程通过system V通信，那就不能使用相同的key值，如果key设置的太简单，就很容易冲突。

ftok函数，就利用算法生成不易重复的key值。

使用ftok函数需要头文件<sys/types.h>和<sys/ipc.h>，函数原型如下：

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

参数：

• pathname：当前操作系统下的某一条路径
• proj_id：一个数字

也就是说，只要传入一个路径和一个数字，ftok就会生成一个key值。

示例：

int main()
{
    key_t key = ftok("./test.cpp", 1);

    cout << key << endl;

    return 0;
}

利用相对路径，使用了路径./test.cpp作为第一个参数，第二个参数设置为了1，最后输出ftok生成的key值。

输出结果：

最后生成的key值为17003535。

要注意的是，path必须是一个存在的路径，ftok函数会利用路径所指向的文件的属性，以及传入的第二个参数，一起来产生这个key值。

需要进程间通信的双方，只需要事先约定好这个path以及第二个整型，就可以利用ftok产生相同的key值，进而访问同一块共享内存了。

---

到目前为止，我们只是讲解了如何来开辟一个共享内存，还没有真正使用这一块共享内存来实现进程间通信

也就是下图中的蓝色部分：

接下来就看看如何使用这一块共享内存。

挂接共享内存

shmat

共享内存是被直接映射到进程地址空间的共享区的，进程可以通过访问进程地址空间来访问共享内存，那么现在的问题就是：如何让一个内存映射到进程地址空间中？这个把共享内存映射到进程地址空间的过程，叫做挂接共享内存。

挂接共享内存需要通过shmat接口实现，需要头文件<sys/types.h>和<sys/shm.h>，函数原型如下：

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

参数：

• shmid：即被挂接的共享内存的shmid
• shmaddr：指明这个共享内存要挂接到哪一个地址，一般来说我们不会主动指定地址，这个参数直接传入空指针即可，操作系统会自动帮我们选择合适的地址挂接
• shmflg：挂接共享内存的模式，
  • 传入0：以读写的方式挂接共享内存
  • 传入SHM_RDONLY：以只读的方式挂接共享内存

返回值：

• 如果挂接共享内存出错，返回-1
• 如果挂接共享内存成功，返回挂接后共享内存的地址

---

shmdt

如果你想要取消对共享内存的挂接，使用shmdt接口即可，需要头文件<sys/types.h>和<sys/shm.h>，函数原型如下：

int shmdt(const void *shmaddr);

只需要把挂接到的共享内存的地址传入shmdt即可取消挂接。

---

现在我们就利用共享内存来完成一次进程间通信，现有A.exe和B.exe两个进程，A负责发送消息，B负责接收消息。

A进程代码如下：

int main()
{
    key_t key = ftok("./test.cpp", 1);
    int shmid = shmget(key, 4096, IPC_CREAT | IPC_EXCL | 0666);

    char* ptr = (char*)shmat(shmid, nullptr, 0);

    for(int ch = 'A'; ch <= 'Z'; ch++)
    {
        ptr[ch - 'A'] = ch;
        sleep(1);
    }

    shmctl(shmid, IPC_RMID, nullptr);

    return 0;
}

一开始A通过ftok生成了一个key值，然后利用shmget生成了一个共享内存，再用shmat将共享内存挂接到进程地址空间，此时ptr指针就指向这个共享内存了，随后利用循环将字母A - Z写入共享内存中，每秒写入一个。最后利用shmctl关闭共享内存。

B进程代码如下：

int main()
{
    key_t key = ftok("./test.cpp", 1);
    int shmid = shmget(key, 4096, IPC_CREAT);

    char* ptr = (char*)shmat(shmid, nullptr, 0);

    while(true)
    {
        cout << ptr << endl;
        sleep(5);
    }


    return 0;
}

B进程也通过ftok生成了key值，由于参数都是"./test.cpp"和1，所以生成的key和A一定是一样的。

随后通过shmget获得共享内存的shmid，这个共享内存是由A维护的，因此B只需要拿到shmid即可，共享内存的创建和销毁都由A来控制。

随后B进程在一个循环中，每隔五秒读取一次共享内存。

输出结果：

可以看到，A进程向共享内存写入的数据，此时就可以被B拿到了，这就是基于共享内存shm的进程间通信。

---

shm特性

共享内存有以下一些主要特性：

1. 内存共享：多个进程可以同时访问和修改同一块共享内存区域。这种共享内存机制可以让进程之间高效地交换数据,而无需通过系统调用或者其他进程间通信机制。

2. 快速访问 ：相比于其他进程间通信机制，如管道、消息队列等，共享内存的访问速度更快，因为数据直接存储在内存中，不需要进行数据的拷贝和上下文切换。

3. 灵活性：共享内存可以在进程之间自由分配和管理，大小和位置都可以灵活设置。这种灵活性使得共享内存非常适合用于复杂的进程间通信场景。

4. 同步问题 ：多个进程可以并发访问和修改共享内存，因此需要使用信号量、互斥锁等同步机制来协调对共享内存的访问，避免数据竞争和不一致性问题。

5. 内存分配 ：共享内存是由内核管理的，进程无法直接分配和释放共享内存，必须通过系统调用如 shmget() 和 shmctl() 来完成。

---

system V 的后两种通信方式消息队列 msg和信号量 sem都非常不常用了，本博客中只是简单讲解，不深入研究。

消息队列 msg

消息队列顾名思义，是一个被操作系统维护的队列：

进程可以向消息队列中写入或者读取消息，上图中，每个黄色的小方块就是一条消息，在消息的头部会有一个区域用于标识，这条消息是哪一个进程发出的。

msgget

msgget 用于创建一个消息队列，需要头文件<sys/types.h>、<sys/ipc.h>和<sys/msg.h>，函数原型如下：

int msgget(key_t key, int msgflg);

返回值：

msgget返回一个整型，这个整型叫做msgid，用于标识唯一的msg。

参数：

• key：即标识唯一的system V的key值

• msgflg： 用于指定消息队列的访问权限和其他选项

  • IPC_CREAT： 如果指定的key不存在，则创建一个新的消息队列，如果已经存在，则直接获得原先的消息队列

  • IPC_EXCL： 如果指定的key已经存在，则创建失败

IPC_EXCL只能配合IPC_CREAT一起使用，不能单独使用IPC_EXCL。

消息队列也可以设置读写权限，直接将权限值的八进制按位或到第二个参数中即可。

你会发现，其实消息队列和共享内存的使用方法几乎是一摸一样的！

---

msgctl

msgctl 用于控制共享内存的各种属性，需要头文件<sys/types.h>、<sys/ipc.h>和<sys/msg.h>，函数原型如下：

int msgctl(int msgid, int cmd, struct msgid_ds* buf);

返回值：

• 成功时返回 0
• 失败时返回 -1，并设置 errno 变量

参数如下：

• shmid：要操作的消息队列的标识符
• cmd：要执行的操作,可以是以下值之一：
  • IPC_STAT：获取消息队列的状态信息
  • IPC_SET：设置消息队列的某些属性
  • IPC_RMID：删除消息队列
• buf：指向 msgid_ds 结构体的指针，用于存储或设置消息队列的属性

msgid_ds源码如下：

struct msqid_ds {
    struct ipc_perm msg_perm;     /* Ownership and permissions */
    time_t          msg_stime;    /* Time of last msgsnd(2) */
    time_t          msg_rtime;    /* Time of last msgrcv(2) */
    time_t          msg_ctime;    /* Time of last change */
    unsigned long   __msg_cbytes; /* Current number of bytes in
                                     queue (nonstandard) */
    msgqnum_t       msg_qnum;     /* Current number of messages
                                     in queue */
    msglen_t        msg_qbytes;   /* Maximum number of bytes
                                     allowed in queue */
    pid_t           msg_lspid;    /* PID of last msgsnd(2) */
    pid_t           msg_lrpid;    /* PID of last msgrcv(2) */
};

这一块和共享内存也几乎是一摸一样的，不过多解释了。

---

刚刚两个接口解决的是消息队列的创建与释放，接下来看看消息队列如何向队列中写入与读取。

msgsnd

msgsnd用于向消息队列写入，需要头文件<sys/types.h>、<sys/ipc.h>和<sys/msg.h>，函数原型如下：

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

函数返回值:

• 成功时，返回 0
• 失败时，返回 -1 并设置 errno 变量

参数：

1. msqid：要发送消息的消息队列的标识符
2. msgp：指向要发送的消息内容的指针
3. msgsz：要发送的消息内容的长度，以字节为单位
4. msgflg：控制 msgsnd() 行为的标志位，一般来说传入0即可。常用的有：
   • IPC_NOWAIT: 如果消息队列已满,立即返回而不是阻塞
   • MSG_NOERROR: 如果消息内容太长，截断后仍然发送

此处要着重讲解一下第二个参数msgp：

msgp 参数是一个指向要发送消息内容的指针。通常情况下，这个消息内容会被存储在一个自定义的结构体中，这个结构体要满足以下格式：

struct msgbuf {
    long mtype;       /* message type, must be > 0 */
    char mtext[1];    /* message data */
};

这个结构体有两个成员变量:

1. mtype：这是一个 long 类型的消息类型标识符。发送消息时,接收方可以根据消息类型来选择性地接收消息。

2. mtext：这是一个字符数组，用于存储实际的消息内容，它的大小可以根据需要进行调整。

在使用 msgsnd() 函数发送消息时,msgp 参数就是指向这个 msg_buf 结构体的指针。

我们在发送消息时，只需要定义一个结构体，结构体的名称可以是任意的，第一个成员必须是long类型，第二个成员必须是char的数组，数组长度任意。

第一个成员一般用于标识不同进程，比如在一个消息队列中，A进程发送的消息，mtype设置为1，B进程发送的消息，mtype设置为2，这样就可以根据这个成员来辨别一条消息是哪个进程发送的了。

---

msgrcv

msgrcv用于从消息队列提取，需要头文件<sys/types.h>、<sys/ipc.h>和<sys/msg.h>，函数原型如下：

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

返回值：

• 成功时，返回实际接收的消息长度
• 失败时，返回 -1 并设置 errno 变量

参数：

1. msqid：要从中接收消息的消息队列的标识符
2. msgp：指向用于存储接收消息内容的缓冲区的指针
3. msgsz：缓冲区 msgp 的大小，以字节为单位
4. msgtyp：指定要接收的消息类型。可以是以下几种情况:
   • 如果 msgtyp > 0，则接收第一个 mtype 等于 msgtyp 的消息。
   • 如果 msgtyp == 0，则接收消息队列中第一个消息，不管 mtype 是什么。
5. msgflg: 控制 msgrcv() 行为的标志位，一般设为0即可。常用的有：
   • IPC_NOWAIT：如果消息队列为空,立即返回而不是阻塞
   • MSG_NOERROR：如果接收的消息内容太长，将其截断后仍然返回

---

再简单讲解两个消息队列相关的系统指令：

ipcs -q用于查看消息队列：

ipcrm -q xxx：用于删除msgid为xxx的消息队列

---

接下来讲解system V的最后一种通信方式信号量 sem。

信号量 sem

信号量的基本原理，在于把一份资源拆分为很多份小资源：

多个进程可以分别访问这个资源的一小部分：

但是不允许多个进程同时访问一个小份资源！

而信号量的作用就是预定资源，信号量本质是一个计数器，用于记录当前还有多少可以分配的资源。

信号量的申请过程如下：

1. 进程访问资源前，要先申请一个信号量，用于预定资源，一旦预定成功，信号量的数目减少一个，即当前剩余的资源少一个。从预定成功开始，这一份资源就不能被其他进程再访问了。
2. 进程申请到信号量后，就可以正常访问这一份资源了
3. 当进程使用完，于是释放信号量，此时信号量数目加一，即当前剩余资源增加一个。

关于信号量，本博客不讲解接口如何使用了，其使用方式比较麻烦，需要很大篇幅，而且信号量也不常用。

---

System V 管理机制

同为system V系列，共享内存 shm、消息队列 msg和信号量 sem是有共性的，操作系统对这三者进行统一的管理。

Linux中，描述三者的结构体如下：

其中共享内存 shm被结构体shmid_kernel管理，消息队列 msg被结构体msg_quque管理，信号量 sem被结构体sem_array管理。不过以上结构体中，成员并不是完全的，我只截取了一小部分。

Linux是如下对system V进行管理的：

ipc_ids结构体的entires成员指向了结构体ipc_id_ary，ipc_id_ary的第二个成员是一个柔性数组，该数组是一个指针数组，指向了不同的system V结构体。此时Linux对system V的管理就变成了对数组的增删查改。

那么现在有一个问题就是：为什么一个数组可以指向三种不同类型的结构体变量？

我们再回到三个描述system V的结构体：

它们三个结构体的第一个成员分别是shm_perm、q_perm和sem_perm，这三者其实都是同一个结构体类型struct kern_ipc_perm，而Linux就是通过这个struct kern_ipc_perm来同时管理三种结构体的。

ipc_id_ary中，第二个成员数组的类型是struct kern_ipc_perm*，也就是指向struct kern_ipc_perm指针，这个struct kern_ipc_perm存储了三种system V都具有的属性。struct kern_ipc_perm结构体同时也都是三个system V的结构体的第一个成员，因此在访问具体的某个结构体时，只需要进行一次指针的强制类型转换即可。

Linux就是通过这样一种方式，把所有的system V都统一地管理了起来。

---