如何下载网站模板文件在哪里,网站服务器费用,新闻稿范文,下沙做网站的旭日新摊子好耶#xff01;
系统从0开始搭建过通信方案#xff0c;本地通信方案的代码#xff1a;System V IPC
里面有共享内存、消息队列、信号量
共享内存
原理
两个进程有自己的内存区域划分#xff0c;共享内存被创建出的时候是归属操作系统的#xff0c;还是通过…旭日新摊子好耶
系统从0开始搭建过通信方案本地通信方案的代码System V IPC
里面有共享内存、消息队列、信号量
共享内存
原理
两个进程有自己的内存区域划分共享内存被创建出的时候是归属操作系统的还是通过页表来映射以使用物理内存
而用地址空间进行映射让两个进程看到同一份物理内存的方式叫共享内存
所有的操作都是操作系统完成的但是它并不知道什么时候做决定通信的是进程 所以OS必须提供系统调用供进程进行调用共享内存在系统中可以同时存在多份供不同个数不同对进程同时进行通信共享内存不是简单的一段内存空间也要有描述并管理共享内存的数据结构和匹配的算法
对共享内存的管理最后要变成对链表的增删查改共享内存 内存空间数据 内存属性
代码
怎样创建共享内存呢
需要看一个函数捏 第二个参数代表共享内存的大小第三个参数代表标记位
它本质采取位图的方式传参
标志位 IPC_CREAT如果要创建的共享内存不存在就创建若存在就获取该共享内存并返回总能获取一个 IPC_EXCL单独使用无意义 IPC_CREAT | IPC_EXCL如果要创建的共享内存不存在创建存在则出错并返回成功返回的一定是全新的 有个问题进程如何知道操作系统是否存在捏
肯定有标识共享内存唯一性的字段进程通过唯一性标识符发现
如果让OS自动生成这个标识符是否可行
不行耶进程母鸡啊
key由用户形成只要有唯一性即可
key是用来标识共享内存唯一性的字段是由用户设计的有统一标准就能一个创建一个获取
由于我们也不知道该设定多少所以系统为我们提供了一个随机生成key的函数ftok 于是可以这样设计
#define __SHM_HPP__
#ifdef __SHM_HPP__#includeiostream
#includesys/shm.h
#includesys/ipc.h
#includecerrno
#includecstdio
#includestringconst std::string pathname /root/ice/pineapple/shm;
const int proj_id 0x49;key_t GetCommKey(const std::string pathname,int proj_id)
{key_t k ftok(pathname.c_str(),proj_id);if(k 0){perror(ftok);}return k;
}#endif 我们微笑的弧度一样了 shmget的返回值是共享内存的标识符
共享内存不随着进程的结束而释放一直存在直到系统重启
要手动释放指令或者其他系统调用
文件的生命周期随进程而共享内存的生命周期随内核
可以这样查共享内存
ipcs -m 想要删除这个共享内存
ipcrm -m shmid 那key和shmid有何区别呢
key是用户形成内核使用的一个字段用户不能用key进行shm的管理是内核进行区分shm唯一性的
而shmid是内核返回给用户的一个标识符是用来进行用户级对共享内存进行管理的id值
对上面的代码进行封装
#define __SHM_HPP__
#ifdef __SHM_HPP__#includeiostream
#includesys/shm.h
#includesys/ipc.h
#includecerrno
#includecstdio
#includestringconst int gCreater 1;
const int gUser 2;
const std::string gpathname /root/ice/pineapple/shm;
const int gproj_id 0x49;
const int gShmSize 4096;class Shm
{
private:
key_t GetCommKey()
{key_t k ftok(_pathname.c_str(),_proj_id);if(k 0){perror(ftok);}return k;
}
//创建共享内存
int ShmGet(key_t key,int size,int flag)
{int shmid shmget(key,size,flag);if(shmid 0){perror(shmget);}return shmid;
}
public:Shm(const std::string pathname, int proj_id,int who):_pathname(pathname),_proj_id(proj_id),_who(who){_key GetCommKey();if(_who gCreater) GetShmUserCreate();else if(_who gUser) GetShmForUse();}~Shm();//转十六进制捏
std::string ToHex()
{char buffer[128];snprintf(buffer,sizeof(buffer),0x%x,_key);return buffer;
}
bool GetShmUserCreate()
{if(_who gCreater){_shmid ShmGet(_key,gShmSize,IPC_CREAT | IPC_EXCL);if(_shmid 0){return true;}}return false;
}
bool GetShmForUse()
{if(_who gUser){_shmid ShmGet(_key,gShmSize,IPC_CREAT);if(_shmid 0){return true;}}return false;
}private:key_t _key;int _shmid;std::string _pathname;int _proj_id;int _who;
}; 删除共享内存老是用指令删太挫了看我这招 了解一下这个 一个命令标志共享内存删除
加上析构
#define __SHM_HPP__
#ifdef __SHM_HPP__#includeiostream
#includesys/shm.h
#includesys/ipc.h
#includecerrno
#includecstdio
#includestring
#includeunistd.hconst int gCreater 1;
const int gUser 2;
const std::string gpathname /root/ice/pineapple/shm;
const int gproj_id 0x49;
const int gShmSize 4096;class Shm
{
private:
key_t GetCommKey()
{key_t k ftok(_pathname.c_str(),_proj_id);if(k 0){perror(ftok);}return k;
}
//创建共享内存
int ShmGet(key_t key,int size,int flag)
{int shmid shmget(key,size,flag);if(shmid 0){perror(shmget);}return shmid;
}
public:Shm(const std::string pathname, int proj_id,int who):_pathname(pathname),_proj_id(proj_id),_who(who){_key GetCommKey();if(_who gCreater) GetShmUserCreate();else if(_who gUser) GetShmForUse();}~Shm(){if(_who gCreater){int res shmctl(_shmid,IPC_RMID,nullptr);}std::cout shm remove done ... std::endl;}//转十六进制捏
std::string ToHex()
{char buffer[128];snprintf(buffer,sizeof(buffer),0x%x,_key);return buffer;
}
bool GetShmUserCreate()
{if(_who gCreater){_shmid ShmGet(_key,gShmSize,IPC_CREAT | IPC_EXCL);if(_shmid 0){return true;}}return false;
}
bool GetShmForUse()
{if(_who gUser){_shmid ShmGet(_key,gShmSize,IPC_CREAT);if(_shmid 0){return true;}}return false;
}private:key_t _key;int _shmid;std::string _pathname;int _proj_id;int _who;
};
#endif 要完成剩下的操作需要挂接一下 共享内存滞销shmat帮帮我们
shmat是将共享内存挂接到地址空间中shmdt是取消挂接
void *shmat(int shmid,const void *shmaddr,int shmflg); 第一个参数是我们申请的共享内存第二个参数是我们想挂接到哪个地址上第三个参数指共享内存的访问权限
先写下代码
Shm.hpp:
#define __SHM_HPP__
#ifdef __SHM_HPP__#includeiostream
#includesys/shm.h
#includesys/ipc.h
#includecerrno
#includecstdio
#includestring
#includeunistd.hconst int gCreater 1;
const int gUser 2;
const std::string gpathname /root/ice/pineapple/shm;
const int gproj_id 0x49;
const int gShmSize 4096;class Shm
{
private:
key_t GetCommKey()
{key_t k ftok(_pathname.c_str(),_proj_id);if(k 0){perror(ftok);}return k;
}
//创建共享内存
int ShmGet(key_t key,int size,int flag)
{int shmid shmget(key,size,flag);if(shmid 0){perror(shmget);}return shmid;
}
std::string RoleToString(int who)
{if(who gCreater){return Creater;}else if(who gUser){return User;}else{return None;}
}
public:Shm(const std::string pathname, int proj_id,int who):_pathname(pathname),_proj_id(proj_id),_who(who),_addrshm(nullptr){_key GetCommKey();if(_who gCreater) GetShmUserCreate();else if(_who gUser) GetShmForUse();_addrshm AttachShm();}~Shm(){if(_who gCreater){int res shmctl(_shmid,IPC_RMID,nullptr);}std::cout shm remove done ... std::endl;}//转十六进制捏
std::string ToHex()
{char buffer[128];snprintf(buffer,sizeof(buffer),0x%x,_key);return buffer;
}
bool GetShmUserCreate()
{if(_who gCreater){_shmid ShmGet(_key,gShmSize,IPC_CREAT | 0666); //不用IPC_EXCL,避免在已经存在的时候出错if(_shmid 0){return true;}std::cout shm create done... std::endl;}return false;
}
bool GetShmForUse()
{if(_who gUser){_shmid ShmGet(_key,gShmSize,IPC_CREAT);if(_shmid 0){return true;}}return false;
}
void *AttachShm()
{if(_addrshm ! nullptr){DetachShm(_addrshm);}void *shmaddr shmat(_shmid,nullptr,0); if(shmaddr (void*)-1){perror(shmat);}std::cout AttachShm RoleToString(_who) std::endl;return shmaddr;
}void DetachShm(void *shmaddr)
{if(shmaddr nullptr){return;}shmdt(shmaddr);std::cout DetachShm RoleToString(_who) std::endl;
}
void *Addr()
{return _addrshm;
}private:key_t _key;int _shmid;std::string _pathname;int _proj_id;int _who;void *_addrshm;
};#endif
server.cc:
#includeShm.hppint main()
{//又是一天什么都没有改变Shm shm(gpathname,gproj_id,gCreater);char* shmaddr (char*)shm.Addr(); while (true){std::cout shm memory content: shmaddr std::endl;sleep(1);}return 0;
} client.cc:
#includeShm.hppint main()
{Shm shm(gpathname,gproj_id,gUser);char* shmaddr (char*)shm.Addr(); char ch A;while (ch Z){shmaddr[ch - A] ch;ch;sleep(1);}return 0;
}
while :; do ipcs -m;sleep 1;done perm表示共享内存的权限所以我们在创建的时候应该指定一下权限
截止目前我们是否开始通信了呢
没有啊
我们还没通信过之前干的都是准备工作啊亲
eeeee哈哈哈哈哈哈
呜呜呜呜
啦啦啦啦啦啦啦啦
我碎掉咯
给自己提个醒写错过的地方 我们需要让挂接前共享内存先清空所以添加个接口Shm.hpp里面Shm的成员函数Zero
void Zero()
{if(_addrshm){memset(_addrshm,0,gShmSize);}
}
#includeShm.hppint main()
{Shm shm(gpathname,gproj_id,gUser);shm.Zero();char* shmaddr (char*)shm.Addr(); char ch A;while (ch Z){shmaddr[ch - A] ch;ch;sleep(1);}return 0;
}
我现在遇到了一个问题我刚发现我设置权限为0666了但是共享内存的权限依旧是0但这不是最离谱的最离谱的是我的服务端和我的客户端都可以正常挂接上 本着遇到困难睡大觉的原则我问了chat好几遍调试信息也多次显示创建出的权限就是0我真的不知道我哪里错了所以决定在这里粘个源代码供后人嘲笑相当于权限都是0但是所有人可读可写可访问
Shm.hpp:
#define __SHM_HPP__
#ifdef __SHM_HPP__#includeiostream
#includesys/shm.h
#includesys/ipc.h
#includecerrno
#includecstdio
#includecstring
#includestring
#includeunistd.hconst int gCreater 1;
const int gUser 2;
const std::string gpathname /root/ice/pineapple/shm;
const int gproj_id 0x49;
const int gShmSize 4096;class Shm
{
private:
key_t GetCommKey()
{key_t k ftok(_pathname.c_str(),_proj_id);if(k 0){perror(ftok);}return k;
}
//创建共享内存
// int ShmGet(key_t key,int size,int flag)
// {
// int shmid shmget(key,size,flag);
// if(shmid 0)
// {
// perror(shmget);
// }
// return shmid;
// }
std::string RoleToString(int who)
{if(who gCreater){return Creater;}else if(who gUser){return User;}else{return None;}
}
public:Shm(const std::string pathname, int proj_id,int who):_pathname(pathname),_proj_id(proj_id),_who(who),_addrshm(nullptr){_key GetCommKey();if(_who gCreater) GetShmUserCreate();else if(_who gUser) GetShmForUse();_addrshm AttachShm();}~Shm(){if(_who gCreater){int res shmctl(_shmid,IPC_RMID,nullptr);}std::cout shm remove done ... std::endl;}//转十六进制捏
std::string ToHex()
{char buffer[128];snprintf(buffer,sizeof(buffer),0x%x,_key);return buffer;
}
bool GetShmUserCreate()
{if(_who gCreater){_shmid shmget(_key,gShmSize,IPC_CREAT | 0666); //不用IPC_EXCL,避免在已经存在的时候出错//调试代码我看看权限是什么会不会是显示的问题struct shmid_ds shm_info;if (shmctl(_shmid, IPC_STAT, shm_info) -1) {perror(shmctl IPC_STAT);} else {std::cout Created Shm Permissions: std::oct shm_info.shm_perm.mode std::endl;}if(_shmid 0){return true;}std::cout shm create done... std::endl;}return false;
}
bool GetShmForUse()
{if(_who gUser){_shmid shmget(_key,gShmSize,IPC_CREAT | 0666); //哈哈真是令人忍俊不禁struct shmid_ds shm_info;//调试代码我看看权限是什么会不会是显示的问题if (shmctl(_shmid, IPC_STAT, shm_info) -1) {perror(shmctl IPC_STAT);} else {std::cout Created Shm Permissions: std::oct shm_info.shm_perm.mode std::endl;}if(_shmid 0){return true;}}return false;
}// // 更改共享内存权限我先注释掉
// void SetShmPermissions(int shmid, mode_t perms)
// {
// struct shmid_ds shm_info;
// if (shmctl(shmid, IPC_STAT, shm_info) -1)
// {
// perror(shmctl IPC_STAT);
// return;
// }// shm_info.shm_perm.mode perms;
// if (shmctl(shmid, IPC_SET, shm_info) -1)
// {
// perror(shmctl IPC_SET);
// }
// }void *AttachShm()
{if(_addrshm ! nullptr){DetachShm(_addrshm);}void *shmaddr shmat(_shmid,nullptr,0); if(shmaddr (void*)-1){perror(shmat);}std::cout AttachShm RoleToString(_who) std::endl;return shmaddr;
}void DetachShm(void *shmaddr)
{if(shmaddr nullptr){return;}shmdt(shmaddr);std::cout DetachShm RoleToString(_who) std::endl;
}void Zero()
{if(_addrshm){memset(_addrshm,0,gShmSize);}
}void *Addr()
{return _addrshm;
}private:key_t _key;int _shmid;std::string _pathname;int _proj_id;int _who;void *_addrshm;
};#endif
Server.cc:
#includeShm.hppint main()
{//又是一天什么都没有改变Shm shm(gpathname,gproj_id,gCreater);char* shmaddr (char*)shm.Addr(); while (true){std::cout shm memory content: shmaddr std::endl;sleep(1);}return 0;
}
Client.cc:
#includeShm.hppint main()
{Shm shm(gpathname,gproj_id,gUser);char* shmaddr (char*)shm.Addr(); char ch A;while (ch Z){shmaddr[ch - A] ch;ch;sleep(1);}return 0;
}
这是一些报错信息 《这确实是不寻常的》 要爱自己不要为难自己
共享内存不提供对共享内存的任意保护机制会造成数据不一致的问题
这是缺点
我们在访问共享内存的时候没有使用系统调用
共享内存是所有进程IPC速度最快的因为共享内存大大的减少了数据的拷贝次数
我们可以基于管道对双方进行保护
namedPiped.hpp
#pragma once#includeiostream
#includesys/types.h
#includesys/stat.h
#includecerrno
#includecstdio
#includeunistd.h
#includestring
#includefcntl.h#define DefaultFd -1
#define Creater 1
#define User 2
#define Read O_RDONLY
#define Write O_WRONLY
#define BaseSize 4096const std::string comm_path ./myfifo;class NamePiped
{
private://打开文件的模式bool OpenNamedPipe(int mode){_fd open(_fifo_path.c_str(),mode);if(_fd 0){return 0;}return true;}
public:NamePiped(const std::string path,int who):_fifo_path(path), _id(who),_fd(DefaultFd){if(_id Creater){int res mkfifo(path.c_str(),0666);if(res ! 0){perror(mkfifo);}}}bool OpenForRead(){return OpenNamedPipe(Read);}bool OpenForWrite(){return OpenNamedPipe(Write);}//输出const :const std::string XXX//输入* std::string *//输入输出 std::string int ReadNamedPipe(std::string *out){char buffer[BaseSize];int n read(_fd,buffer,sizeof(buffer));if(n 0){//读取成功buffer[n] 0;*out buffer;}return n;}int WriteNamedPipe(const std::string in){return write(_fd,in.c_str(),in.size());}~NamePiped(){if(_id Creater){int res unlink(_fifo_path.c_str());if(res ! 0){perror(unlink);}}if(_fd ! DefaultFd){close(_fd);}}
private:const std::string _fifo_path;int _id;int _fd;
}; Shm.hpp
#define __SHM_HPP__
#ifdef __SHM_HPP__#includeiostream
#includesys/shm.h
#includesys/ipc.h
#includecerrno
#includecstdio
#includecstring
#includestring
#includeunistd.hconst int gCreater 1;
const int gUser 2;
const std::string gpathname /root/ice/pineapple/shm;
const int gproj_id 0x49;
const int gShmSize 4096;class Shm
{
private:
key_t GetCommKey()
{key_t k ftok(_pathname.c_str(),_proj_id);if(k 0){perror(ftok);}return k;
}
//创建共享内存
// int ShmGet(key_t key,int size,int flag)
// {
// int shmid shmget(key,size,flag);
// if(shmid 0)
// {
// perror(shmget);
// }
// return shmid;
// }
std::string RoleToString(int who)
{if(who gCreater){return Creater;}else if(who gUser){return User;}else{return None;}
}
public:Shm(const std::string pathname, int proj_id,int who):_pathname(pathname),_proj_id(proj_id),_who(who),_addrshm(nullptr){_key GetCommKey();if(_who gCreater) GetShmUserCreate();else if(_who gUser) GetShmForUse();_addrshm AttachShm();}~Shm(){if(_who gCreater){int res shmctl(_shmid,IPC_RMID,nullptr);}std::cout shm remove done ... std::endl;}//转十六进制捏
std::string ToHex()
{char buffer[128];snprintf(buffer,sizeof(buffer),0x%x,_key);return buffer;
}
bool GetShmUserCreate()
{if(_who gCreater){_shmid shmget(_key,gShmSize,IPC_CREAT | 0666); //不用IPC_EXCL,避免在已经存在的时候出错//调试代码我看看权限是什么会不会是显示的问题struct shmid_ds shm_info;if (shmctl(_shmid, IPC_STAT, shm_info) -1) {perror(shmctl IPC_STAT);} else {std::cout Created Shm Permissions: std::oct shm_info.shm_perm.mode std::endl;}if(_shmid 0){return true;}std::cout shm create done... std::endl;}return false;
}
bool GetShmForUse()
{if(_who gUser){_shmid shmget(_key,gShmSize,IPC_CREAT | 0666); //哈哈真是令人忍俊不禁struct shmid_ds shm_info;//调试代码我看看权限是什么会不会是显示的问题if (shmctl(_shmid, IPC_STAT, shm_info) -1) {perror(shmctl IPC_STAT);} else {std::cout Created Shm Permissions: std::oct shm_info.shm_perm.mode std::endl;}if(_shmid 0){return true;}}return false;
}// // 更改共享内存权限我先注释掉
// void SetShmPermissions(int shmid, mode_t perms)
// {
// struct shmid_ds shm_info;
// if (shmctl(shmid, IPC_STAT, shm_info) -1)
// {
// perror(shmctl IPC_STAT);
// return;
// }// shm_info.shm_perm.mode perms;
// if (shmctl(shmid, IPC_SET, shm_info) -1)
// {
// perror(shmctl IPC_SET);
// }
// }void *AttachShm()
{if(_addrshm ! nullptr){DetachShm(_addrshm);}void *shmaddr shmat(_shmid,nullptr,0); if(shmaddr (void*)-1){perror(shmat);}std::cout AttachShm RoleToString(_who) std::endl;return shmaddr;
}void DetachShm(void *shmaddr)
{if(shmaddr nullptr){return;}shmdt(shmaddr);std::cout DetachShm RoleToString(_who) std::endl;
}void Zero()
{if(_addrshm){memset(_addrshm,0,gShmSize);}
}void *Addr()
{return _addrshm;
}private:key_t _key;int _shmid;std::string _pathname;int _proj_id;int _who;void *_addrshm;
};#endif client.cc
#includeShm.hpp
#includenamedPiped.hppint main()
{//创建共享内存Shm shm(gpathname,gproj_id,gUser);char* shmaddr (char*)shm.Addr(); //打开管道NamePiped fifo(comm_path,User);fifo.OpenForWrite();char ch A;while (ch Z){shmaddr[ch - A] ch;ch;std::string temp wakeup;std::cout add ch into Shm, wakeup reader std::endl;fifo.WriteNamedPipe(temp);sleep(1);}return 0;
} server.cc
#includeShm.hpp
#includenamedPiped.hppint main()
{//又是一天什么都没有改变//创建共享内存Shm shm(gpathname,gproj_id,gCreater);char* shmaddr (char*)shm.Addr(); //创建管道NamePiped fifo(comm_path,Creater);fifo.OpenForRead();while (true){std::string temp;fifo.ReadNamedPipe(temp);std::cout shm memory content: shmaddr std::endl;sleep(1);}return 0;
} 共享内存的设置最好设置成4096的整数倍如果多一点点会浪费
因为操作系统只会给你分配4096的整数倍的共享内存
怎样获取共享内存的属性捏 void DebugShm()
{struct shmid_ds ds;int n shmctl(_shmid,IPC_STAT,ds);if(n 0){return;}std::cout ds.shm_perm.__key: ToHex(ds.shm_perm.__key) std::endl;std::cout ds.shm_nattch: ds.shm_nattch std::endl;
} System V消息队列
原理
操作系统申请个队列现在有两个进程进程A进程B进程A可以使用消息队列的调用接口向消息队列中放数据块消息队列是一个进程向另一个进程发送数据块的方式操作系统也要先描述在组织所以不仅要有消息队列还要有相应的属性数据
接口
那有哪些接口呢让我们康康
int msgget(key_t key,int msgflg); 这个接口是在获取消息队列
key_t fork(const char *pathname,int proj_id); 消息队列使用的时候和共享内存差不多不想用了的话就可以用msgctl捏
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); 使用消息队列需要我们自定义一个结构体msgbuf
struct msgbuf
{long mtype; /*message type,must be 0 */char mtext[1]; /*message data */
};
这个大小是自己定义的捏
发消息是这样的捏
#define A 1
#define B 2
struct msgbuf message;
message.mtype B;
message.mtext (hello world);
msgsnd(msgid,message,sizeof(message),0); 收消息则可以这样干
#define A 1
#define B 2
struct msgbuf recvbuffer;
msgrcv(msgid,recvbuffer,sizeof(recvbuffer),A,0);
msgrcv(msgid,recvbuffer,sizeof(recvbuffer),B,0);
指令操作
生命周期是随内核的鹅可以这样查看消息队列
ipcs -q 删除的话就是
ipcrm -q msqid 距离永远不会成为阻碍 毛豆好可爱 很好笑下了拜拜
