Linux进程间通信
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
文章目录
进程间通信介绍
进程间通信的概念
进程间通信简称IPC（Interprocess communication）进程间通信就是在不同进程之间传播或交换信息。
进程间通信的目的
- 数据传输 : 一个进程需要将它的数据发送给另一个进程。
- 资源共享： 多个进程之间共享同样的资源。
- 通知事件： 一个进程需要向另一个或一组进程发送消息通知它（它们）发生了某种事件比如进程终止时需要通知其父进程。
- 进程控制： 有些进程希望完全控制另一个进程的执行（如Debug进程）此时控制进程希望能够拦截另一个进程的所有陷入和异常并能够及时知道它的状态改变。
进程间通信的本质
进程间通信的本质就是让不同的进程看到同一份资源。
由于各个运行进程之间具有独立性这个独立性主要体现在数据层面而代码逻辑层面可以私有也可以公有（例如父子进程）因此各个进程之间要实现通信是非常困难的。
各个进程之间若想实现通信一定要借助第三方资源这些进程就可以通过向这个第三方资源写入或是读取数据进而实现进程之间的通信这个第三方资源实际上就是操作系统提供的一段内存区域。
因此进程间通信的本质就是让不同的进程看到同一份资源（内存文件内核缓冲等）。 由于这份资源可以由操作系统中的不同模块提供因此出现了不同的进程间通信方式。
进程间通信的分类
管道
- 匿名管道
- 命名管道
System V IPC
- System V 消息队列
- System V 共享内存
- System V 信号量
POSIX IPC
- 消息队列
- 共享内存
- 信号量
- 互斥量
- 条件变量
- 读写锁
管道
什么是管道
管道是Unix中最古老的进程间通信的形式我们把从一个进程连接到另一个进程的数据流称为一个“管道”。
例如统计我们当前使用云服务器上的USER为root的进程
其中ps aux命令和grep root命令都是两个程序当它们运行起来后就变成了两个进程ps aux进程通过标准输出将数据打到“管道”当中grep root进程再通过标准输入从“管道”当中读取数据至此便完成了数据的传输进而完成数据的进一步加工处理。
匿名管道
匿名管道的原理
匿名管道用于进程间通信且仅限于
本地父子进程之间的通信。
进程间通信的本质就是让不同的进程看到同一份资源使用匿名管道实现父子进程间通信的原理就是让两个父子进程先看到同一份被打开的文件资源然后父子进程就可以对该文件进行写入或是读取操作进而实现父子进程间通信。
此图 来源 2021dragon
注意
- 这里父子进程看到的同一份文件资源是由操作系统来维护的所以当父子进程对该文件进行写入操作 时该文件缓冲区当中的数据并不会进行写时拷贝。
- 管道虽然用的是文件的方案但操作系统一定不会把进程进行通信的数据刷新到磁盘当中因为这样做有IO参与会降低效率而且也没有必要。也就是说这种文件是一批不会把数据写到磁盘当中的文件换句话说磁盘文件和内存文件不一定是一一对应的有些文件只会在内存当中存在而不会在磁盘当中存在。
pipe函数
pipe函数用于创建匿名管道pip函数的函数原型如下：
int pipe(int pipefd[2]);
pipe函数的参数是一个输出型参数数组pipefd用于返回两个指向管道读端和写端的文件描述符：
| 数组元素 | 含义 |
|---|---|
| pipefd[0] | 管道读端的文件描述符 |
| pipefd[1] | 管道写端的文件描述符 |
pipe函数调用成功时返回0调用失败时返回-1。
匿名管道使用步骤
在创建匿名管道实现父子进程间通信的过程中需要pipe函数和fork函数搭配使用具体步骤如下：
1、父进程调用pipe函数创建管道。
2、父进程创建子进程。
3、父进程关闭写端子进程关闭读端。
注意：
-
管道只能够进行单向通信因此当父进程创建完子进程后需要确认父子进程谁读谁写然后关闭相应的读写端。
-
从管道写端写入的数据会被内核缓冲直到从管道的读端被读取。
我们可以站在文件描述符的角度再来看看这三个步骤：
1、父进程调用pipe函数创建管道。
2、父进程创建子进程。
3、父进程关闭写端子进程关闭读端。
例如在以下代码当中父进程向匿名管道当中写入5行数据子进程从匿名管道当中将数据读出。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
int main()
{
// 创建管道
int pipe_fd[2] = {0};
if (pipe(pipe_fd) != 0)
{
cerr << "pipe error" << endl;
return 1;
}
// 创建子进程
pid_t id = fork();
if (id > 0)
{
// father write
close(pipe_fd[0]); // 关闭读端
string msg = "I am father";
int cnt = 5; // 发送五次消息
while (cnt--)
{
sleep(2);
write(pipe_fd[1], msg.c_str(), msg.size());
}
close(pipe_fd[1]); // 关掉写端
cout << "父进程结束了,消息发完了" << endl;
}
else if (id == 0)
{
// child read
char buffer[1024];
memset(buffer, 0, sizeof(buffer));
close(pipe_fd[1]); // 关闭写端
while (true)
{
size_t s = read(pipe_fd[0], buffer, sizeof(buffer) - 1); // 给\0留位置
if (s == 0)
{
cout << "父进程写完了我要退出啦" << endl;
break;
}
else if (s > 0)
{
buffer[s] = '\0';
cout << "我收到消息了 : " << buffer << endl;
}
else
{
// 啥都不做
}
}
close(pipe_fd[0]);
exit(0);
}
else
{
cerr << "fork error" << endl;
return 2;
}
pid_t res = waitpid(id, nullptr, 0);
if (res > 0)
cout << "等待子进程成功" << endl;
return 0;
}
管道读写规则
int pipe2(int pipefd[2], int flags);
pipe2函数的第二个参数用于设置选项。
1、当没有数据可读时
- O_NONBLOCK disable：read调用阻塞即进程暂停执行一直等到有数据来为止。
- O_NONBLOCK enable：read调用返回-1errno值为EAGAIN。
2、当管道满的时候：
- O_NONBLOCK disable：write调用阻塞直到有进程读走数据。
- O_NONBLOCK enable：write调用返回-1errno值为EAGAIN。
3、如果所有管道写端对应的文件描述符被关闭则read返回0。
4、如果所有管道读端对应的文件描述符被关闭则write操作会产生信号SIGPIPE进而可能导致write进程退出。
5、当要写入的数据量不大于PIPE_BUF时Linux将保证写入的原子性。
6、当要写入的数据量大于PIPE_BUF时Linux将不再保证写入的原子性。
管道的特点
1、管道内部自带同步与互斥机制。
我们将一次只允许一个进程使用的资源称为临界资源。管道在同一时刻只允许一个进程对其进行写入或是读取操作因此管道也就是一种临界资源。
临界资源是需要被保护的若是我们不对管道这种临界资源进行任何保护机制那么就可能出现同一时刻有多个进程对同一管道进行操作的情况进而导致同时读写、交叉读写以及读取到的数据不一致等问题。
为了避免这些问题内核会对管道操作进行同步与互斥：
- 同步： 两个或两个以上的进程在运行过程中协同步调按预定的先后次序运行。比如A任务的运行依赖于B任务产生的数据。
- 互斥： 一个公共资源同一时刻只能被一个进程使用多个进程不能同时使用公共资源。
实际上同步是一种更为复杂的互斥而互斥是一种特殊的同步。对于管道的场景来说互斥就是两个进程不可以同时对管道进行操作它们会相互排斥必须等一个进程操作完毕另一个才能操作而同步也是指这两个不能同时对管道进行操作但这两个进程必须要按照某种次序来对管道进行操作。
也就是说互斥具有唯一性和排它性但互斥并不限制任务的运行顺序而同步的任务之间则有明确的顺序关系。
2、管道的生命周期随进程。
管道本质上是通过文件进行通信的也就是说管道依赖于文件系统那么当所有打开该文件的进程都退出后该文件也就会被释放掉所以说管道的生命周期随进程。
3、管道提供的是流式服务。
对于进程A写入管道当中的数据进程B每次从管道读取的数据的多少是任意的这种被称为流式服务与之相对应的是数据报服务
- 流式服务： 数据没有明确的分割不分一定的报文段。
- 数据报服务: 数据有明确的分割拿数据按报文段拿。
在数据通信中数据在线路上的传送方式可以分为以下三种：
-
单工通信(Simplex Communication)：单工模式的数据传输是单向的。通信双方中一方固定为发送端另一方固定为接收端。
-
半双工通信(Half Duplex)：半双工数据传输指数据可以在一个信号载体的两个方向上传输但是不能同时传输。
-
全双工通信(Full Duplex)：全双工通信允许数据在两个方向上同时传输它的能力相当于两个单工通信方式的结合。全双工可以同时(瞬时)进行信号的双向传输。
管道是半双工的数据只能向一个方向流动需要双方通信时需要建立起两个管道
管道的四种特殊情况
在使用管道时可能出现以下四种特殊情况：
- 写端进程不写读端进程一直读那么此时会因为管道里面没有数据可读对应的读端进程会被挂起直到管道里面有数据后读端进程才会被唤醒。
- 读端进程不读写端进程一直写那么当管道被写满后对应的写端进程会被挂起直到管道当中的数据被读端进程读取后写端进程才会被唤醒。
- 写端进程将数据写完后将写端关闭那么读端进程将管道当中的数据读完后就会继续执行该进程之后的代码逻辑而不会被挂起。
- 读端进程将读端关闭而写端进程还在一直向管道写入数据那么操作系统会将写端进程杀掉。
其中前面两种情况就能够很好的说明管道是自带同步与互斥机制的读端进程和写端进程是有一个步调协调的过程的不会说当管道没有数据了读端还在读取而当管道已经满了写端还在写入。读端进程读取数据的条件是管道里面有数据写端进程写入数据的条件是管道当中还有空间若是条件不满足则相应的进程就会被挂起直到条件满足后才会被再次唤醒。
第三种情况也很好理解读端进程已经将管道当中的所有数据都读取出来了而且此后也不会有写端再进行写入了那么此时读端进程也就可以执行该进程的其他逻辑了而不会被挂起。
第四种情况也不难理解既然管道当中的数据已经没有进程会读取了那么写端进程的写入将没有意义因此操作系统直接将写端进程杀掉。而此时子进程代码都还没跑完就被终止了属于异常退出那么子进程必然收到了某种信号。
我们可以通过以下代码看看情况四中子进程退出时究竟是收到了什么信号。
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
int fd[2] = { 0 };
if (pipe(fd) < 0){ //使用pipe创建匿名管道
perror("pipe");
return 1;
}
pid_t id = fork(); //使用fork创建子进程
if (id == 0){
//child
close(fd[0]); //子进程关闭读端
//子进程向管道写入数据
const char* msg = "hello father, I am child...";
int count = 10;
while (count--){
write(fd[1], msg, strlen(msg));
sleep(1);
}
close(fd[1]); //子进程写入完毕关闭文件
exit(0);
}
//father
close(fd[1]); //父进程关闭写端
close(fd[0]); //父进程直接关闭读端（导致子进程被操作系统杀掉）
int status = 0;
waitpid(id, &status, 0);
printf("child get signal:%d\n", status & 0x7F); //打印子进程收到的信号
return 0;
}
运行结果显示子进程退出时收到的是13号信号。
通过kill -l命令可以查看13对应的具体信号。
由此可知当发生情况四时操作系统向子进程发送的是SIGPIPE信号将子进程终止的。
管道的大小
管道的容量是有限的如果管道已满那么写端将阻塞或失败那么管道的最大容量是多少呢？
方法一：使用man手册
根据man手册在2.6.11之前的Linux版本中管道的最大容量与系统页面大小相同从Linux 2.6.11往后管道的最大容量是65536字节。
然后我们可以使用uname -r命令查看自己使用的Linux版本。
根据man手册我使用的是Linux 2.6.11之后的版本因此管道的最大容量是65536字节
方法二：使用ulimit命令
其次我们还可以使用ulimit -a命令查看当前资源限制的设定。
根据显示管道的最大容量是 512 × 8 = 4096 512\times8=4096512×8=4096 字节。
方法三：自行测试
这里发现根据man手册得到的管道容量与使用ulimit命令得到的管道容量不同那么此时我们可以自行进行测试。
前面说到若是读端进程一直不读取管道当中的数据写端进程一直向管道写入数据当管道被写满后写端进程就会被挂起。据此我们可以写出以下代码来测试管道的最大容量。
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
int fd[2] = { 0 };
if (pipe(fd) < 0){ //使用pipe创建匿名管道
perror("pipe");
return 1;
}
pid_t id = fork(); //使用fork创建子进程
if (id == 0){
//child
close(fd[0]); //子进程关闭读端
char c = 'a';
int count = 0;
//子进程一直进行写入一次写入一个字节
while (1){
write(fd[1], &c, 1);
count++;
printf("%d\n", count); //打印当前写入的字节数
}
close(fd[1]);
exit(0);
}
//father
close(fd[1]); //父进程关闭写端
//父进程不进行读取
waitpid(id, NULL, 0);
close(fd[0]);
return 0;
}
可以看到在读端进程不进行读取的情况下写端进程最多写65536字节的数据就被操作系统挂起了也就是说我当前Linux版本中管道的最大容量是65536字节
命名管道
命名管道的原理
匿名管道只能用于具有共同祖先的进程（具有亲缘关系的进程）之间的通信通常一个管道由一个进程创建然后该进程调用fork此后父子进程之间就可应用该管道。
如果要实现两个毫不相关进程之间的通信可以使用命名管道来做到。命名管道就是一种特殊类型的文件两个进程通过命名管道的文件名打开同一个管道文件此时这两个进程也就看到了同一份资源进而就可以进行通信了。
注意：
- 普通文件是很难做到通信的即便做到通信也无法解决一些安全问题。
- 命名管道和匿名管道一样都是内存文件只不过命名管道在磁盘有一个简单的映像但这个映像的大小永远为0因为命名管道和匿名管道都不会将通信数据刷新到磁盘当中。
使用命令创建命名管道
我们可以使用mkfifo命令创建一个命名管道。
可以看到创建出来的文件的类型是p代表该文件是命名管道文件。
使用这个命名管道文件就能实现两个进程之间的通信了。我们在一个进程（进程A）中用shell脚本每秒向命名管道写入一个字符串在另一个进程（进程B）当中用cat命令从命名管道当中进行读取。
现象就是当进程A启动后进程B会每秒从命名管道中读取一个字符串打印到显示器上。这就证明了这两个毫不相关的进程可以通过命名管道进行数据传输即通信。
之前我们说过当管道的读端进程退出后写端进程再向管道写入数据就没有意义了此时写端进程会被操作系统杀掉在这里就可以很好的得到验证：当我们终止掉读端进程后因为写端执行的循环脚本是由命令行解释器bash执行的所以此时bash就会被操作系统杀掉我们的云服务器也就退出了。
创建一个命名管道
在程序中创建命名管道使用mkfifo函数mkfifo函数的函数原型如下：
int mkfifo(const char *pathname, mode_t mode);
mkfifo函数的第一个参数是pathname表示要创建的命名管道文件。
- 若pathname以路径的方式给出则将命名管道
- 文件创建在pathname路径下。
若pathname以文件名的方式给出则将命名管道文件默认创建在当前路径下。（注意当前路径的含义）
mkfifo函数的第二个参数是mode表示创建命名管道文件的默认权限。
例如将mode设置为0666则命名管道文件创建出来的权限如下：
但实际上创建出来文件的权限值还会受到umask（文件默认掩码）的影响实际创建出来文件的权限为：mode&(~umask)。umask的默认值一般为0002当我们设置mode值为0666时实际创建出来文件的权限为0664。
若想创建出来命名管道文件的权限值不受umask的影响则需要在创建文件前使用umask函数将文件默认掩码设置为0。
umask(0); //将文件默认掩码设置为0
mkfifo函数的返回值。
- 命名管道创建成功返回0。
- 命名管道创建失败返回-1。
创建命名管道示例：
使用以下代码即可在当前路径下创建出一个名为myfifo的命名管道。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#define FILE_NAME "myfifo"
int main()
{
umask(0); //将文件默认掩码设置为0
if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
perror("mkfifo");
return 1;
}
//create success...
return 0;
}
运行代码后命名管道myfifo就在当前路径下被创建了。
命名管道的打开规则
1、如果当前打开操作是为读而打开FIFO时。
- O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO。
- O_NONBLOCK enable：立刻返回成功。
2、如果当前打开操作是为写而打开FIFO时。
- O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO。
- O_NONBLOCK enable：立刻返回失败错误码为ENXIO。
用命名管道实现serve&client通信
实现服务端(server)和客户端(client)之间的通信之前我们需要先让服务端运行起来我们需要让服务端运行后创建一个命名管道文件然后再以读的方式打开该命名管道文件之后服务端就可以从该命名管道当中读取客户端发来的通信信息了。
服务端的代码如下：
//server.c
#include "comm.h"
int main()
{
umask(0); //将文件默认掩码设置为0
if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
perror("mkfifo");
return 1;
}
int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
if (fd < 0){
perror("open");
return 2;
}
char msg[128];
while (1){
msg[0] = '\0'; //每次读之前将msg清空
//从命名管道当中读取信息
ssize_t s = read(fd, msg, sizeof(msg)-1);
if (s > 0){
msg[s] = '\0'; //手动设置'\0'便于输出
printf("client# %s\n", msg); //输出客户端发来的信息
}
else if (s == 0){
printf("client quit!\n");
break;
}
else{
printf("read error!\n");
break;
}
}
close(fd); //通信完毕关闭命名管道文件
return 0;
}
而对于客户端来说因为服务端运行起来后命名管道文件就已经被创建了所以客户端只需以写的方式打开该命名管道文件之后客户端就可以将通信信息写入到命名管道文件当中进而实现和服务端的通信。
客户端的代码如下：
//client.c
#include "comm.h"
int main()
{
int fd = open(FILE_NAME, O_WRONLY); //以写的方式打开命名管道文件
if (fd < 0){
perror("open");
return 1;
}
char msg[128];
while (1){
msg[0] = '\0'; //每次读之前将msg清空
printf("Please Enter# "); //提示客户端输入
fflush(stdout);
//从客户端的标准输入流读取信息
ssize_t s = read(0, msg, sizeof(msg)-1);
if (s > 0){
msg[s - 1] = '\0';
//将信息写入命名管道
write(fd, msg, strlen(msg));
}
}
close(fd); //通信完毕关闭命名管道文件
return 0;
}
对于如何让客户端和服务端使用同一个命名管道文件这里我们可以让客户端和服务端包含同一个头文件该头文件当中提供这个共用的命名管道文件的文件名这样客户端和服务端就可以通过这个文件名打开同一个命名管道文件进而进行通信了。
共用头文件的代码如下：
//comm.h
#pragma once
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#define FILE_NAME "myfifo" //让客户端和服务端使用同一个命名管道
代码编写完毕后先将服务端进程运行起来之后我们就能在客户端看到这个已经被创建的命名管道文件。
接着再将客户端也运行起来此时我们从客户端写入的信息被客户端写入到命名管道当中服务端再从命名管道当中将信息读取出来打印在服务端的显示器上该现象说明服务端是能够通过命名管道获取到客户端发来的信息的换句话说此时这两个进程之间是能够通信的。
当客户端和服务端运行起来时我们还可以通过ps命令查看这两个进程的信息可以发现这两个进程确实是两个毫不相关的进程因为它们的PID和PPID都不相同。也就证明了命名管道是可以实现两个毫不相关进程之间的通信的。
服务端和客户端之间的退出关系
当客户端退出后服务端将管道当中的数据读完后就再也读不到数据了那么此时服务端也就会去执行它的其他代码了（在当前代码中是直接退出了）。
当服务端退出后客户端写入管道的数据就不会被读取了也就没有意义了那么当客户端下一次再向管道写入数据时就会收到操作系统发来的13号信号(SIGPIPE)此时客户端就被操作系统强制杀掉了。
通信是在内存当中进行的
若是我们只让客户端向管道写入数据而服务端不从管道读取数据那么这个管道文件的大小会不会发生变化呢？
//server.c
#include "comm.h"
int main()
{
umask(0); //将文件默认掩码设置为0
if (mkfifo(FILE_NAME, 0666) < 0){ //使用mkfifo创建命名管道文件
perror("mkfifo");
return 1;
}
int fd = open(FILE_NAME, O_RDONLY); //以读的方式打开命名管道文件
if (fd < 0){
perror("open");
return 2;
}
while (1){
//服务端不读取管道信息
}
close(fd); //通信完毕关闭命名管道文件
return 0;
}
可以看到尽管服务端不读取管道当中的数据但是管道当中的数据并没有被刷新到磁盘使用ll命令看到命名管道文件的大小依旧为0也就说明了双方进程之间的通信依旧是在内存当中进行的和匿名管道通信是一样的。
命名管道和匿名管道的区别
- 匿名管道由pipe函数创建并打开。
- 命名管道由mkfifo函数创建由open函数打开。
- FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在于它们创建与打开的方式不同一旦这些工作完成之后它们具有相同的语义。
system V进程间通信
管道通信本质是基于文件的也就是说操作系统并没有为此做过多的设计工作而system V IPC是操作系统特地设计的一种通信方式。但是不管怎么样它们的本质都是一样的都是在想尽办法让不同的进程看到同一份由操作系统提供的资源。
system V IPC提供的通信方式有以下三种：
- system V共享内存
- system V消息队列
- system V信号量
其中system V共享内存和system V消息队列是以传送数据为目的的而system V信号量是为了保证进程间的同步与互斥而设计的虽然system V信号量和通信好像没有直接关系但属于通信范畴。
system V共享内存和system V消息队列就类似于手机用于沟通信息；system V信号量就类似于下棋比赛时用的棋钟用于保证两个棋手之间的同步与互斥。
system V共享内存
共享内存的基本原理
共享内存让不同进程看到同一份资源的方式就是在物理内存当中申请一块内存空间然后将这块内存空间分别与各个进程各自的页表之间建立映射再在虚拟地址空间当中开辟空间并将虚拟地址填充到各自页表的对应位置使得虚拟地址和物理地址之间建立起对应关系至此这些进程便看到了同一份物理内存这块物理内存就叫做共享内存。
注意：
这里所说的开辟物理空间、建立映射等操作都是调用系统接口完成的也就是说这些动作都由操作系统来完成。
共享内存数据结构
在系统当中可能会有大量的进程在进行通信因此系统当中就可能存在大量的共享内存那么操作系统必然要对其进行管理所以共享内存除了在内存当中真正开辟空间之外系统一定还要为共享内存维护相关的内核数据结构。
共享内存的数据结构如下：
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 */
};
当我们申请了一块共享内存后为了让要实现通信的进程能够看到同一个共享内存因此每一个共享内存被申请时都有一个key值这个key值用于标识系统中共享内存的唯一性。
可以看到上面共享内存数据结构的第一个成员是shm_permshm_perm是一个ipc_perm类型的结构体变量每个共享内存的key值存储在shm_perm这个结构体变量当中其中ipc_perm结构体的定义如下：
struct ipc_perm{
__kernel_key_t key;
__kernel_uid_t uid;
__kernel_gid_t gid;
__kernel_uid_t cuid;
__kernel_gid_t cgid;
__kernel_mode_t mode;
unsigned short seq;
};
记录一下:
共享内存的数据结构shmid_ds和ipc_perm结构体分别在/usr/include/linux/shm.h和/usr/include/linux/ipc.h中定义。
共享内存的建立与释放
共享内存的建立大致包括以下两个过程：
- 在物理内存当中申请共享内存空间。
- 将申请到的共享内存挂接到地址空间即建立映射关系。
共享内存的释放大致包括以下两个过程：
- 将共享内存与地址空间去关联即取消映射关系。
- 释放共享内存空间即将物理内存归还给系统。
共享内存的创建
创建共享内存我们需要用shmget函数shmget函数的函数原型如下：
int shmget(key_t key, size_t size, int shmflg);
shmget函数的参数说明：
-
第一个参数key表示待创建共享内存在系统当中的唯一标识。
-
第二个参数size表示待创建共享内存的大小。
-
第三个参数shmflg表示创建共享内存的方式。
shmget函数的返回值说明: -
shmget调用成功返回一个有效的共享内存标识符（用户层标识符）。
-
shmget调用失败返回-1。
注意： 我们把具有标定某种资源能力的东西叫做句柄而这里shmget函数的返回值实际上就是共享内存的句柄这个句柄可以在用户层标识共享内存当共享内存被创建后我们在后续使用共享内存的相关接口时都是需要通过这个句柄对指定共享内存进行各种操作。
传入shmget函数的第一个参数key需要我们使用ftok函数进行获取
ftok函数的函数原型如下：
key_t ftok(const char *pathname, int proj_id);
ftok函数的作用就是将一个已存在的路径名pathname和一个整数标识符proj_id转换成一个key值称为IPC键值在使用shmget函数获取共享内存时这个key值会被填充进维护共享内存的数据结构当中。需要注意的是pathname所指定的文件必须存在且可存取。
注意：
- 使用ftok函数生成key值可能会产生冲突此时可以对传入ftok函数的参数进行修改。
- 需要进行通信的各个进程在使用ftok函数获取key值时都需要采用同样的路径名和和整数标识符进而生成同一种key值然后才能找到同一个共享资源。
传入shmget函数的第三个参数shmflg常用的组合方式有以下两种：
| 组合方式 | 作用 |
|---|---|
| IPC_CREAT | 如果内核中不存在键值与key相等的共享内存则新建一个共享内存并返回该共享内存的句柄；如果存在这样的共享内存则直接返回该共享内存的句柄 |
| IPC_CREAT I IPC_EXCL | 如果内核中不存在键值与key相等的共享内存则新建一个共享内存并返回该共享内存的句柄；如果存在这样的共享内存则出错返回 |
换句话说：
- 使用组合IPC_CREAT一定会获得一个共享内存的句柄但无法确认该共享内存是否是新建的共享内存。
- 使用组合IPC_CREAT | IPC_EXCL只有shmget函数调用成功时才会获得共享内存的句柄并且该共享内存一定是新建的共享内存。
至此我们就可以使用ftok和shmget函数创建一块共享内存了创建后我们可以将共享内存的key值和句柄进行打印以便观察代码如下：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#define PATHNAME "/home/cl/Linuxcode/IPC/shm/server.c" //路径名
#define PROJ_ID 0x6666 //整数标识符
#define SIZE 4096 //共享内存的大小
int main()
{
key_t key = ftok(PATHNAME, PROJ_ID); //获取key值
if (key < 0){
perror("ftok");
return 1;
}
int shm = shmget(key, SIZE, IPC_CREAT | IPC_EXCL); //创建新的共享内存
if (shm < 0){
perror("shmget");
return 2;
}
printf("key: %x\n", key); //打印key值
printf("shm: %d\n", shm); //打印句柄
return 0;
}
该代码编写完毕运行后我们可以看到输出的key值和句柄值：