共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间,这些进程间数据传递不再涉及到内核,换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据
通过让不同的进程,看到同一个内存块的方式,就叫做共享内存
函数参数int shmflg
(标记位传参):
lPC_CREAT
:如果不存在,创建之,如果存在,获取之
IPC_EXCL
:
IPC_CREAT|IPC_EXCL
:如果不存在,创建之,如果存在,就出错返回shmget
返回值:在不同操作系统可能不一样,它虽然是数组下标,但是它跟我们之前学习过的文件系统的下标是不一样的,是两套体系,而它的返回值我们把它当成是一个标识符就行了
函数参数key_t key
:
我们是只有shmget()创建完以后才有返回值,但是为了保证两个需要通信的进程看到的是同一个内存块,需要有标识符确定。而这个key值是什么不重要,重要的是能进行唯一性标识最重要。
我们在生成key值需要调用另外一个函数:ftok
我们只需要在
ftok
的参数传入相同的pathname
与proj_id
那么它生成的key
值也一定是一样的,然后我们的两个进程就能通过这个key值找到这个内存块
ftok
函数的原型如下:
key_t ftok(const char *pathname, int proj_id);
pathname
参数是一个指向文件路径名的指针,proj_id
参数是一个整数值。ftok
函数会根据pathname
和proj_id
生成一个key
值,并将其返回。
使用 ftok
函数时,需要注意以下几点:
pathname
参数必须指向一个存在的文件,否则 ftok 函数会返回错误。proj_id
参数是一个可以自定义的整数值,用于在同一个文件的不同共享内存区域之间进行区分。如果不同的共享内存区域使用相同的 proj_id 值,则它们将被视为同一个共享内存区域。key
值的生成是基于 st_dev
和 st_ino
两个文件属性值的。因此,如果 pathname 参数对应的文件属性值发生了改变,那么生成的 key 值也会发生改变。comm.hpp
:
#ifndef _COMM_HPP_
#define _COMM_HPP_
#include
#include
#include
#include
#include
#include
#include
#define PATHNAME "."
#define PROJ_ID 0x66
// 共享内存的大小,一般建议是4KB的整数倍
// 系统分配共享内存是以4KB为单位的! --- 内存划分内存块的基本单位Page
#define MAX_SIZE 4096 // --- 内核给你的会向上取整, 内核给你的,和你能用的,是两码事
key_t getKey()
{
key_t k = ftok(PATHNAME, PROJ_ID); //可以获取同样的一个Key!
if(k < 0)
{
// cin, cout, cerr -> stdin, stdout, stderr -> 0, 1, 2
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);
}
#endif
shm_server.cpp
:
#include "comm.hpp"
#include
int main()
{
key_t k = getKey();
printf("key: 0x%x\n", k); // key
int shmid = createShm(k);
printf("shmid: %d\n", shmid); //shmid
delShm(shmid);
return 0;
}
shm_client.cpp
:
#include "comm.hpp"
#include
int main()
{
key_t k = getKey();
printf("key: 0x%x\n", k);
int shmid = getShm(k);
printf("shmid: %d\n", shmid);
return 0;
}
在前面我们说过,OS中那么多进程需要通信,当然共享内存也可能同时存在很多,由于进程独立性,共享内存肯定是OS生成的,那么OS生成这些共享内存肯定也需要对其进行管理 -> 管理的方法:先描述再组织:
共享内存 = 物理内存块 + 共享内存相关属性
在创建共享内存时,为了保证共享内存存在系统中是唯一的,是使用key
标识
共享内存标识符shmid
是一个整数,由操作系统分配并唯一标识共享内存段。在使用共享内存时,不同的进程可以通过共享内存标识符访问同一个共享内存段
key
是要shmget
,设置进入共享内存属性中的!用来表示该共享内存,在内核中的唯一性!!
shmid
类似于fd
,而key
类似于inode
,shmid
与key
的关系类似锁与钥匙
ipc资源的特征:
按道理我们的bash结束就代表这个进程结束,那么我们继续执行却发现创建失败,这是为什么?
共享内存的生命周期是随OS的,而不是随进程的–这是所有system V
版本的共性
查看IPC资源:
ipcs -m/-q/-s
删除这个资源:
ipcrm -m (shmid值)2
直观上你可能想使用key值去删除,因为key值具有唯一性,但是 不是,因为key值仅仅只是内核里面用来标识唯一性的,并不是让用户去操纵共享内存的,而指令是在应用层,用户要使用经常用来控制共享内存的id去操纵它,也就是shmid的值
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
//成功返回0,失败返回-1并设置errno变量以指示错误类型
参数cmd
是一个控制命令,用于指定对共享内存的操作类型,常见的操作类型包括:
IPC_STAT
:获取共享内存的状态信息,将共享内存的状态信息保存在buf参数指向的shmid_ds结构体中。IPC_SET
:设置共享内存的状态信息,将buf参数指向的shmid_ds结构体中的状态信息应用到共享内存中。IPC_RMID
:删除共享内存,将共享内存从系统中删除。IPC_INFO
:获取系统中IPC机制的状态信息,将IPC机制的状态信息保存在buf参数指向的ipc_info结构体中。SHM_LOCK
:锁定共享内存,防止它被换出到交换空间中。SHM_UNLOCK
:解锁共享内存,允许它被换出到交换空间中参数buf
是一个指向共享内存的数据结构shmid_ds
的指针,用于获取和修改共享内存的状态信息。shmid_ds结构体定义在
buf
如果传nullptr
的话,shmctl()函数会忽略buf参数,并且不会获取或修改共享内存的状态信息。shmid_ds
结构体指针作为buf参数,否则shmctl()函数将会返回错误并设置errno变量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 */
...
};
封装:删除共享内存:
//comm.hpp
void delShm(int shmid)
{
if(shmctl(shmid, IPC_RMID, nullptr) == -1)
{
std::cerr << errno << " : " << strerror(errno) << std::endl;
}
}
void *shmat(int shmid, const void *shmaddr, int shmflg);
这个void*
的返回值就等价于以前的malloc
的返回值
函数参数:
参数shmaddr
是指定共享内存连接的地址
参数shmflg
是用于指定共享内存连接的标志,它控制共享内存连接的行为。shmflg参数可以是以下标志的按位或组合:
SHM_RDONLY
:只读访问共享内存,即使共享内存段是可写的。SHM_RND
:将shmaddr参数舍入到系统页面大小的整数倍。这个标志在shmaddr参数不为0或NULL时才有意义。SHM_REMAP
:将共享内存连接到一个新的地址,如果shmaddr参数不为0或NULL,则将共享内存连接到指定的地址。SHM_EXEC
:允许执行共享内存中的代码。这个标志只在某些体系结构上有意义。IPC_NOWAIT
:非阻塞模式,如果连接不可用,则立即返回错误而不是等待。SHM_DEST
:在共享内存段上设置IPC_RMID标志,表示共享内存段已经被删除。SHM_HUGETLB
:使用大页面来分配共享内存,以提高性能和效率。不是所有的标志都适用于所有的平台和操作系统,因此在使用
shmat()
函数时,应该根据具体平台和操作系统的要求选择合适的标志,并正确设置shmflg参数。
封装:将当前进程贴到共享内存上:
//comm.hpp
void *attachShm(int shmid)
{
void *mem = shmat(shmid, nullptr, 0); //64系统,8
if((long long)mem == -1L)
{
std::cerr <<"shmat: "<< errno << ":" << strerror(errno) << std::endl;
exit(3);
}
return mem;
}
函数原型:
int shmdt(const void *shmaddr);
函数参数:
shmdt()
函数的参数shmaddr
是共享内存连接的地址,它指向共享内存段的起始地址。该地址是由shmat()
函数返回的,用于标识应用程序与共享内存段之间的连接。
封装:
//comm.hpp
void detachShm(void *start)
{
if(shmdt(start) == -1)
{
std::cerr <<"shmdt: "<< errno << ":" << strerror(errno) << std::endl;
}
}
断开与共享内存段的连接并不会删除共享内存段,只是将该连接从应用程序的地址空间中删除。如果希望删除共享内存段,应该在最后一个使用共享内存段的进程断开连接后,调用shmctl()函数将共享内存段标记为删除状态,然后等待所有进程都将其连接断开后,再调用shmctl()函数将共享内存段从系统中删除。
shm_server.cpp
:
#include "comm.hpp"
#include
int main()
{
key_t k = getKey();
printf("key: 0x%x\n", k); // key
int shmid = createShm(k);
printf("shmid: %d\n", shmid); //shmid
sleep(5);
char *start = (char*)attachShm(shmid);
printf("attach success, address start: %p\n", start);
// 输出
while(true)
{
printf("client say : %s\n", start);
sleep(1);
}
// 去关联
detachShm(start);
sleep(10);
//删除共享内存
delShm(shmid);
return 0;
}
解释:首先创建key值,然后创建共享内存,然后将进程与共享内存相关联,然后将从共享内存得到的数据输出
shm_client.cpp
#include "comm.hpp"
#include
int main()
{
key_t k = getKey();
printf("key: 0x%x\n", k);
int shmid = getShm(k);
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;
while(true)
{
sleep(5);
snprintf(start, MAX_SIZE, "%s[pid:%d][消息编号:%d]", message, id, cnt++);
}
detachShm(start);
return 0;
}
解释:
key
值(由于我们封装了创建key值,创建的路径以及id都是一样的,所以本写入端进程创建的key值与读取端进程创建的key值是一样的,这也是两个进程看到同一份资源(可以是内存块)的前提条件)shmid
值snprintf
以字符串的形式输出到共享内存上面使用的都是封装的接口,如
getKey()/getShm(k)
优点:所有进程间通信,速度是最快的
进程1向进程2传递数据,因为该内存是被双方所共享的,所以我们只要将数据写入共享内存中,对方立即就能看到,所以我们就能大大减少进程1至进程2数据拷贝的次数
面试题:同样的代码,综合考虑管道和共享内存,键盘输入和显示器输出各自有几次数据拷贝?
这里的场景只是单纯的收发消息,如果代码有别的输入输出还需要具体问题具体分析
缺点:没有进行同步与互斥的操作,没有对数据进行保护
思考:如何实现对共享内存的保护呢?
我们可以实现两个管道与共享内存结合的方式,写端写入数据到共享内存后通过管道给读端一个标识,而读端在没有这个标识的时候就阻塞,而不是一直读取,读端读完以后给写端再发一个标识,使得写端继续写,而读端又继续阻塞。
这是呈现给用户的,大致的内核数据结构体,但是内核里面更为复杂
共享内存的属性:
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 */
...
};
struct ipc_perm {
key_t __key; /* Key supplied to shmget(2) */
uid_t uid; /* Effective UID of owner */
gid_t gid; /* Effective GID of owner */
uid_t cuid; /* Effective UID of creator */
gid_t cgid; /* Effective GID of creator */
unsigned short mode; /* Permissions + SHM_DEST and
SHM_LOCKED flags */
unsigned short __seq; /* Sequence number */
};
我么可以在之前读取端打印共享内存的属性以及key值:
//shm_server.cpp
while(true)
{
// char buffer[]; read(pipefd, buffer, ...)
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);
}
如有错误或者不清楚的地方欢迎私信或者评论指出