文章目录
system V IPC提供的通信方式有三种：
共享内存、消息队列、信号量；并且生命周期是随OS的，而不是随进程的，这是所有System V进程间通信的共性`
一、共享内存
1.共享内存的基本原理
共享内存：通过让不同的进程，看到通过一个内存块的方式就叫共享内存
进程具有独立性：内核数据结构包括对应的代码、数据与页表都是独立的。OS系统为了让进程间进行通信：1.申请一块空间 2.将创建好的内存映射进进程的地址空间。共享内存让不同的进程看到同一份的资源就是在物理内存上申请一块内存空间，如何将创建好的内存分别与各个进程的页表之间建立映射，然后在虚拟地址空间中将虚拟地址填充到各自页表的对应位置，建立起物理地址与虚拟地址的联系。
3.如果不想通信：取消进程和内存的映射关系，释放内存
而我们把创建好的内存称为共享内存，把进程和共享内存建立映射关系的操作称为挂接，把取消进程和内存的映射关系称为去关联
把释放内存称为释放共享内存。
共享内存的建立:在物理内存当中申请共享内存空间;将申请到的共享内存挂接到地址空间，即建立映射关系。
共享内存的释放:共享内存与地址空间去关联，即取消映射关系;释放共享内存空间，即将物理内存归还给系统。
对于共享内存的理解：
对比以前C语言的malloc也可以在物理内存申请空间，并把开辟好的空间经过页表映射到进程地址空间当中
但是system V进程间通信是专门设计的，用来IPC；共享内存是一种通信方式，所有想通信的进程都可以进行使用；OS一定可能会同时存在很多的共享内存
2.共享内存的创建
shmget：用来创建共享内存
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
RETURN VALUE
On success, a valid shared memory identifier is returned. On errir, -1 is returned, and errno is set to indicate the error.
参数认识：
shmflg:通常被设置成两个选项： IPC_CREAT、 IPC_EXCL
IPC_CREAT:共享内存不存在，则创建，如果存在则获取；IPC_EXCL:无法单独使用，IPC_CREAT|IPC_EXCL:如果不存在就创建，如果存在就出错返回
size:共享内存的大小
key:保证看到同一份共享内存，能进行唯一性标识。如何去形成key:ftok
ftok:形成key
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);
RETURN VALUE
On success, the generated key_t value is returned. On failure -1 is returned, with errno indicating the error as for the stat(2) system call.
ftok的作用是通过存在的路径名pathname以及设置的标识符proj_id来形成一个key值，通过shmget创建共享内存时，key值会被填充维护共享内存的数据结构当中。
key_t getkey()
{
key_t k = ftok(PATHNAME,PROJ_JD);
if(k <0)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return k;
}
理解key:
OS一定会存在很多的共享内存，共享内存本质就是在内存中申请一块空间，而key能进行唯一标识。OS申请的，自然要做管理，共享内存也是如此，如何管理：先描述，在组织。所以共享内存=物理内存块+共享内存的相关属性。进程如果在内存中创建了共享内存，为了让共享内存在系统中保证唯一的，通过key来进行标识，只要让另一个进程也看到同一个key。而key是在哪？key作为创建共享内存时共享内存的相关属性集合，描述共享内存时就有一个字段struct shm中有key。
共享内存数据结构的第一个成员是shm_perm，shm_perm是一个ipc_perm类型的结构体变量，每个共享内存的key值存储在shm_perm这个结构体变量当中，其中ipc_perm结构体的定义如下：
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 */
};
3.共享内存的控制
shmctl:控制共享内存
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数认识：shmid:控制共享内存的标识符，cmd:控制种类，buf:控制共享内存的数据结构,简单设置为空
返回值:0表示成功，-1表示失败
void delShm(int shmid)
{
if(shmctl(shmid,IPC_RMID,nullptr)==-1)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
}
}
共享内存的内核结构shmid_ds:
//man shmctl
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 */
...
};
4.共享内存的关联
shmat:关联共享内存
#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数认识shmaddr:指定虚拟地址，但是我们并不了解，直接设置为nullptr即可；shmflg:读取权限，默认为0
void * attachShm(int shmid)
{
void*mem = shmat(shmid,nullptr,0);
if((int)mem==-1)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(3);
}
return mem;
}
5.共享内存的去关联
shmdt:去关联
#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);
RETURN VALUE
On success shmdt() returns 0; on error -1 is returned, and errno is set to indi‐cate the cause of the error.
void detachShm(void * start)
{
if(shmdt(start)==-1)
{
cerr<<"shmdt:"<<errno<<":"<<strerror(errno)<<endl;
}
}
6.查看IPC资源
对于管道：进程退出，文件描述符就会自动释放，但是对于共享内存不一样:共享内存的生命周期是随OS的，而不是随进程的，这是所有System V进程间通信的共性,
查看共享内存：ipcs -m
删除：ipcsrm -m + shmid
7.代码实现通信
comm.hpp:
#ifndef __COMM_HPP_
#define __COMM_HPP_
#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;
#define PATHNAME "."
#define PROJ_JD 0x66
#define MAX_SIZE 4096
key_t getkey()
{
key_t k = ftok(PATHNAME,PROJ_JD);
if(k <0)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
exit(1);
}
return k;
}
int getShmHelper(key_t k,int flags)
{
//k是要shmget,设置进入共享内存属性中的，用来标识
//该共享难内存在内核中的唯一性
//shmid与key：
//fd inode
int shmid = shmget(k,MAX_SIZE,flags);
if(shmid<0)
{
cerr<<errno<<":"<<strerror(errno)<<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);
}
void delShm(int shmid)
{
if(shmctl(shmid,IPC_RMID,nullptr)==-1)
{
cerr<<errno<<":"<<strerror(errno)<<endl;
}
}
void * attachShm(int shmid)
{
void*mem = shmat(shmid,nullptr,0);
if((long long)mem==-1L)//64位系统，8个字节，L表示数字类型
{
cerr<<errno<<"shmat:"<<strerror(errno)<<endl;
exit(3);
}
return mem;
}
void detachShm(void * start)
{
if(shmdt(start)==-1)
{
cerr<<"shmdt:"<<errno<<":"<<strerror(errno)<<endl;
}
}
#endif
server.cc
#include "comm.hpp"
#include <unistd.h>
using namespace std;
int main()
{
key_t k = getkey();
printf("key:%0x%x\n",k);
int shmid = createShm(k);
printf("shmid:%d\n",shmid);
//sleep(5);
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",ds.shm_segsz,ds.shm_cpid);
sleep(1);
}
//去关联
detachShm(start);
sleep(10);
//删除共享内存
delShm(shmid);
return 0;
}
client.cc
#include "comm.hpp"
#include <unistd.h>
using namespace std;
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 count = 1;
//char buffer[1024];
while(true)
{
sleep(5);
snprintf(start,MAX_SIZE,"%s[pid:%d][消息编号:%d]",message,id,count++);
// snprintf(buffer,sizeof(buffer),"%s[pid:%d][消息编号:%d]",message,id,count++);
// memcpy(start,buffer,strlen(buffer)+1);
}
detachShm(start);
return 0;
}
8.共享内存的特点
共享内存的生命周期是随OS的，而不是随进程的，这是所有System V进程间通信的共性
优点：共享内存是所有进程间通信速度是最快的，因为共享内存是被双方所共享，只要写入对方就能立即看到，能大大减少数据的拷贝次数。
但是综合考虑管道和共享内存，考虑键盘输入，和显示器输出，对于同一份数据：共享内存有几次数据拷贝，管道有几次数据拷贝
管道：需要通过键盘输入到自己定义的缓冲区char buffer[]，将数据拷贝到buffer中，调用write接口在把buffer里的数据拷贝到管道里，
另一进程也有定义buffer缓冲区，调用read读取把数据从管道里读取到buffer里，在把数据显示到显示器上：
共享内存:通过映射关系
共享内存的缺点：不给我们进行同步和互斥的操作，没有对数据做任何保护。客户端和服务端没做保护，如果想做保护要用到信号量，对共享内存进行保护，写完通过读端进行读取。
二、消息队列（了解）
1.消息队列的概念
消息队列是OS提供的内核级队列，消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法，每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值
2.消息队列数据结构
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) */
};
消息队列数据结构的第一个成员是msg_perm，它和shm_perm是同一个类型的结构体变量，ipc_perm结构体的定义如下：
struct ipc_perm {
key_t __key; /* Key supplied to msgget(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 */
unsigned short __seq; /* Sequence number */
};
3.消息队列相关函数
- msgget:获取消息队列
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);
RETURN VALUE
If successful, the return value will be the message queue identifier (a nonnegative integer), otherwise -1 with errno indicating the error.
key:ftok函数生成一个key值，这个key值作为msgget函数的第一个参数
msgflg:与创建共享内存时使用的shmget函数的第三个参数相同。
返回值:msgget函数返回的一个有效的消息队列标识符
- msgctl:控制消息队列
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
与之前类似接口参数相同
- msgsnd:发数据
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
msqid:表示消息队列的用户级标识符。
msgp:表示待发送的数据块。
msgsz:表示所发送数据块的大小
msgflg：表示发送数据块的方式，一般默认为0即可
成功返回0，失败返回-1
- **msgrcv:**读取消息队列
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
msqid：表示消息队列的用户级标识符。msgp：表示获取到的数据块，是一个输出型参数。
msgsz：表示要获取数据块的大小
msgtyp：表示要接收数据块的类型，msgflg：表示发送数据块的方式，一般默认为0即可
成功返回实际获取到mtext数组中的字节数，失败返回-1。
三、信号量（了解）
1.信号量相关概念
信号量的本质是一个计数器，通常用来表示公共资源中，资源数的多少问题。信号量主要用于同步和互斥的。
公共资源：能被多个进程同时访问的资源，访问没有保护的公共资源：数据不一致问题。要让不同的进程看到同一份资源是为了通信，通信是为了让进程间实现协同，而进程之间具有独立性，所以为了解决独立性问题要让进程看到同一份资源，但是会导致数据不一致的问题。
被保护起来的公共资源称为临界资源，而进程要使用资源一定是该进程有对应的代码来访问这部分临界资源称为临界区，但是多个进程看到同一份资源是少数情况，大部分申请自己的资源用自己的代码区访问。有临界区自然就有非临界区，不访问公共资源的代码。
如何保护公共资源：互斥&&同步
互斥：由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥
原子性：要么不做、要么做完两态的这种情况。比如支付转账
如果用全局的整数来替代信号量？全局的整数在父子关系的进程上都看不到，要发生写时拷贝，而不同的进程更看不到，所以进程间想看到同一个计数器得让进程看到同一个计数器。
为什么要信号量？当我们想要某种资源的时候可以通过信号量进行预；，共享资源被使用的方式：作为一个整体使用；划分成为一个一个的资源部分
2.信号量数据结构
struct semid_ds {
struct ipc_perm sem_perm; /* Ownership and permissions */
time_t sem_otime; /* Last semop time */
time_t sem_ctime; /* Last change time */
unsigned long sem_nsems; /* No. of semaphores in set */
};
信号量数据结构的第一个成员也是ipc_perm类型的结构体变量，ipc_perm结构体的定义如下：
struct ipc_perm {
key_t __key; /* Key supplied to semget(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 */
unsigned short __seq; /* Sequence number */
};
3.信号量pv操作
所有的进程在访问公共资源之前，都必须申请sem信号量，而申请sem信号量的前提是所有进程必须先看到同一个信号量，所以信号量本身就是公共资源，同时，信号量必须保证自身操作的安全性，++,–操作是原子
如果信号量的初始值是1就代表了访问公共资源作为一个整体来使用。二元信号量提供互斥功能
4.信号量相关函数
semget:申请信号量
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
RETURN VALUE
If successful, the return value will be the semaphore set identifier (a nonnegative integer), otherwise -1 is returned, with errno indicating the error.
参数认识：
key:使用ftok函数生成一个key值，这个key值作为semget函数的第一个参数。
nsems:表示创建信号量的个数
第三个参数，与创建共享内存时使用的shmget函数的第三个参数相同。
返回值：信号量集创建成功时，semget函数返回的一个有效的信号量集标识符
- semctl:信号量的删除
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);
- semop:信号量操作
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);
我们可以发现，共享内存、消息队列、信号量接口相似度非常高，获取与删除，都是system V标准的进程间通信。
OS如何管理：先描述，在组织，对相关资源的内核数据结构做管理，对于共享内存、消息队列、信号量的第一个成员都是ipc_perm:
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 */
};
虽然内部的属性差别很大，但是维护它们的数据结构的第一个成员确实一样的，都是ipc_perm类型的成员变量,都可以通过key来标识唯一性。这样设计的好处:在操作系统内可以定义一个struct ipc_perm类型的数组，此时每当我们申请一个IPC资源，就在该数组当中开辟一个这样的结构。((struct shmid_ds*)perms[0]，强转，此时就可以访问其他剩下的属性)
扫一扫
756
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
