Linux知识点 – 进程间通信（二）

文章目录

Linux知识点 -- 进程间通信（二）
一、System V共享内存
- 1.原理
- 2.申请共享内存
- 3.System V共享内存的使用
- 4.为共享内存添加访问控制
二、信号量（概念理解）
- 1.概念
- 2.信号量

一、System V共享内存

1.原理

在这里插入图片描述
先在内存中申请空间，然后将这段空间映射到不同进程的地址空间中，这就叫做共享内存；
一般都是映射在进程的堆栈之间的共享区；
共享内存不属于任何一个进程，它属于操作系统；
操作系统对共享内存的管理，是先描述再组织，先通过内核数据结构描述共享内存的属性信息，再将它们组织起来；
共享内存 = 共享内存块 + 对应的共享内存的内核数据结构；
共享区属于用户空间，不用经过系统调用，直接可以访问；
双方进程如果要通信，直接进行内存级的读写即可；
之前的管道是一种文件。是OS中的一种数据结构，所以用户无权直接访问，需要进行系统调用；

2.申请共享内存

在这里插入图片描述
shmget接口能够申请共享内存；

参数：
key：通信双方的进程，通过key值来保证是通信的双方来创建的共享内存，相当于一个验证值，需要在系统内是唯一的，通信双方使用同一个key；
size：内存大小，一般是页（4byte）的整数倍；
shmflag：有两个选项：IPC_CREAT和IPC_EXCL；
IPC_CREAT能单独出现，代表如果共享内存已存在，则获取之；如果不存在，就创建之，并返回；
IPC_EXCL必须和IPC_CREAT组合使用，代表如果共享内存不存在，就创建之，并返回；如果已存在，出错并返回；
0就代表IPC_CREAT；
返回值：成功会返回共享内存id，失败返回-1；

ftok函数：生成唯一的key
在这里插入图片描述

参数：
==pathname：==文件路径，一定要保证用户有权限；
==id：==项目id，随便给，一般是0 - 255；
返回值：成功，返回key值；失败，返回-1；
ftok会拿路径文件的inode，和id形成一个唯一的key，生成结果是有可能重复的；

3.System V共享内存的使用

Makefile：

.PHONY:all
all:shmClient shmServershmServer:shmServer.ccg++ -o $@ $^ -std=c++11 
shmClient:shmClient.ccg++ -o $@ $^ -std=c++11 .PHONY:clean
claen:rm -f shmServer shmClient

Log.hpp

#ifndef _LOG_H_
#define _LOG_H_#include<iostream>
#include<ctime>#define DeBug   0
#define Notice  1
#define Waring  2
#define Error   3const std::string msg[] = {"DeBug","Notice","Waring","Error"
};std::ostream &Log(std::string message, int level)
{std::cout << " | " << (unsigned)time(nullptr) << " | " << msg[level] << " | " << message;return std::cout;
}
#endif

comm.hpp

#ifndef _COMM_H_
#define _COMM_H_#include<iostream>
#include<cstdio>
#include<unistd.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<cassert>
#include "Log.hpp"using namespace std;#define PATH_NAME "/usr/lmx" //路径，一定保证有权限
#define PROJ_ID 0X66   
#define SHM_SIZE 4096 //共享内存大小，最好是页（4byte）的整数倍#endif

shmServer.cc
#include “comm.hpp”

string TransToHex(key_t k)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), “0x%x”, k);
return buffer;
}

int main()
{
// 1.创建公共的key值
key_t key = ftok(PATH_NAME, PROJ_ID);
if (key == -1)
{
perror(“ftok”);
exit(1);
}

Log("creat key done", DeBug) << "server key : " << TransToHex(key) << endl;// 2.创建共享内存 -- 建议创建一个全新的共享内存 -- 通信的发起者
int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);
if (shmid == -1)
{perror("shmget");exit(2);
}
Log("shm creat done", DeBug) << "shmid : " << shmid << endl;//3.将指定的共享内存，挂接到自己的地址空间
char* shmaddr = (char*)shmat(shmid, nullptr, 0);
Log("attach shm done", DeBug) << "shmid : " << shmid << endl;//这里就是通信逻辑了
//将共享内存看作一个大字符串
//shmaddr就是这个字符串的起始地址
for(;;)
{printf("%s\n", shmaddr);//不断打印这个字符串的内容if(strcmp(shmaddr, "quit") == 0){break;}sleep(1);
}//4.将指定的共享内存，从自己的地址空间中去关联
int n = shmdt(shmaddr);
if(n == -1)
{perror("shmdt");exit(3);
}
Log("detach shm done", DeBug) << "shmid : " << shmid << endl;//5.删除共享内存，IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存
n = shmctl(shmid, IPC_RMID, nullptr);
if(n == -1)
{perror("shmctl");exit(4);
}
Log("delete shm done", DeBug) << "shmid : " << shmid << endl;return 0;

}

注意：
（1）
在这里插入图片描述
要保证创建出唯一的key；*
（2）

创建全新的共享内存，0666代表共享内存的权限；
共享内存的大小最好是页的整数倍，否则会造成空间浪费，多开空间，但是没有权限访问；

第二次创建的时候，提示共享内存已存在；
在这里插入图片描述
（3）ipcs -m：查看共享内存信息；

ipcrm -m shmid：删除共享内存（不能用key删除）
共享内存的生命周期随内核;
与文件不一样，文件的生命周期，如果进程退出，没有其他进程再关联这个文件，那么就会被回收;
在这里插入图片描述

perms属性就是共享内存的权限，

（4）因此，当进程结束后，共享内存还存在，我们继续要删除它，使用系统接口：
shmctl：删除共享内存
在这里插入图片描述

（5）nattch属性是挂接的共享内存个数，共享内存创建好之后，需要挂接在自己的进程地址空间；
shmat：挂接共享内存

参数：
shmid：共享内存id
shmaddr：挂接虚拟地址，直接设为0，让os挂接
shmflg：挂接方式
返回值：成功返回共享内存addr虚拟地址，失败返回-1
使用：
将返回值作为共享内存的起始地址；
在这里插入图片描述
shmdt：去关联

参数：
shmaddr：共享内存地址
返回值：成功返回0，失败返回-1

shmClient.cc

#include "comm.hpp"int main()
{// 客户端也获取keykey_t key = ftok(PATH_NAME, PROJ_ID);if (key < 0){Log("creat key failed", Error) << "client key : " << key << endl;exit(1);}Log("creat key done", DeBug) << "client key : " << key << endl;// 获取共享内存int shmid = shmget(key, SHM_SIZE, 0);if (shmid == -1){Log("creat shm failed", Error) << "client key : " << key << endl;exit(2);}Log("creat shm done", DeBug) << "client key : " << key << endl;// 挂接共享内存char *shmaddr = (char *)shmat(shmid, nullptr, 0);if (shmaddr == nullptr){Log("attach shm failed", Error) << "client key : " << key << endl;}Log("attach shm done", DeBug) << "client key : " << key << endl;// 使用//client将共享内存看作一个char类型的buffer//客户端从键盘读取消息，直接读到共享内存中while (true){ssize_t s = read(0, shmaddr, SHM_SIZE - 1);if(s > 0){shmaddr[s - 1] = 0;if(strcmp(shmaddr, "quit") == 0)//读到quit，客户端退出{break;}}}// char a = 'a';// for(; a <= 'z'; a++)// {//     //每一次都向shmaddr（共享内存的起始地址）写入//     snprintf(shmaddr, SHM_SIZE - 1, //             "hello server, 我是其他进程，我的pid： %d, inc: %c\n", //             getpid(), a);//     sleep(2);// }// 去关联int n = shmdt(shmaddr);if (n == -1){perror("shmdt");exit(3);}Log("detach shm done", DeBug) << "client key : " << key << endl;// client不需要删除shmreturn 0;
}

注意：
（1）共享内存的使用，直接将共享内存看作一个char类型的buffer，直接向里面写入数据
在这里插入图片描述
从stdin中键盘读取消息，直接读取到shmaddr这个地址，即共享内存的起始地址；

运行结果：
服务端：
在这里插入图片描述
客户端：

注：
（1）只要是通信双方使用shm，一方直接向共享内存中写入数据，另一方就可以立马看到对方写入的数据；共享内存是所有进程间通信中最快的，不需要过多的拷贝；
（2）管道通信中，一次通信需要多次拷贝，用户从键盘输入数据到缓冲区是一次拷贝，从缓冲区向管道文件写入数据又是一次拷贝，从管道文件向缓冲区读取数据是一次拷贝，从缓冲区将数据打印又是一次拷贝；

（3）共享内存只需要两次拷贝，从键盘输入的数据直接写入shm，这是一次拷贝，直接将shm的数据打印出来，这是第二次拷贝；
在这里插入图片描述

4.为共享内存添加访问控制

从上面的结果可以看出，即便是客户端还没有挂接共享内存，服务端就已经开始不停读取数据了，这就表明共享内存是不带访问控制的，会带来一定的并发问题；
然而，管道是自带访问控制的，我们可以利用管道通信来为共享内存添加访问控制；
comm.hpp

#ifndef _COMM_H_
#define _COMM_H_#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <cassert>
#include <cstring>
#include <sys/stat.h>
#include <fcntl.h>
#include "Log.hpp"using namespace std;#define PATH_NAME "/home/lmx" // 路径，一定保证有权限
#define PROJ_ID 0X66
#define SHM_SIZE 4096 // 共享内存大小，最好是页（4byte）的整数倍#define FIFO_NAME "./fifo"class Init
{
public:Init(){umask(0);int n = mkfifo(FIFO_NAME, 0666);assert(n == 0);(void)n;Log("creat fifo succsee", Notice) << "\n";}~Init(){unlink(FIFO_NAME);Log("remove fifo succsee", Notice) << "\n";}
};#define READ O_RDONLY
#define WRITE O_WRONLYint OpenFIFO(std::string pathname, int flags)
{int fd = open(pathname.c_str(), flags);assert(fd >= 0);return fd;
}void Wait(int fd)
{Log("waiting...", Notice) << "\n";uint32_t temp = 0;ssize_t s = read(fd, &temp, sizeof(uint32_t));assert(s == sizeof(uint32_t));(void)s;
}void Signal(int fd)
{uint32_t temp = 1;ssize_t s = write(fd, &temp, sizeof(uint32_t));assert(s == sizeof(uint32_t));(void)s;Log("aweaking...", Notice) << "\n";
}void CloseFIFO(int fd)
{close(fd);
}#endif

注：
（1）创建了一个类，类的构造函数有创建管道文件，一旦类实例化出对象，调用构造函数，就能够创建一个管道文件，后面就是对管道文件的读写控制了；
在这里插入图片描述
shmServer.cc

#include "comm.hpp"string TransToHex(key_t k)
{char buffer[32];snprintf(buffer, sizeof(buffer), "0x%x", k);return buffer;
}int main()
{Init init;// 对应的程序在加载的时候，会自动构建全局变量，就要调用该类构造函数 -- 创建管道文件// 程序退出的时候，全局变量会被析构，会自动删除管道文件// 1.创建公共的key值key_t key = ftok(PATH_NAME, PROJ_ID);if (key == -1){perror("ftok");exit(1);}Log("creat key done", DeBug) << "server key : " << TransToHex(key) << endl;// 2.创建共享内存 -- 建议创建一个全新的共享内存 -- 通信的发起者int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);if (shmid == -1){perror("shmget");exit(2);}Log("shm creat done", DeBug) << "shmid : " << shmid << endl;// 3.将指定的共享内存，挂接到自己的地址空间char *shmaddr = (char *)shmat(shmid, nullptr, 0);Log("attach shm done", DeBug) << "shmid : " << shmid << endl;// 这里就是通信逻辑了// 将共享内存看作一个大字符串// shmaddr就是这个字符串的起始地址//使用管道进行访问控制int fd = OpenFIFO(FIFO_NAME, READ);for (;;){Wait(fd);//等待客户端响应，//使用管道文件的访问控制，如果客户端没有向管道内写入数据，那么该进程会一直阻塞printf("%s\n", shmaddr); // 不断打印这个字符串的内容if (strcmp(shmaddr, "quit") == 0){break;}sleep(1);}CloseFIFO(fd);// 4.将指定的共享内存，从自己的地址空间中去关联int n = shmdt(shmaddr);if (n == -1){perror("shmdt");exit(3);}Log("detach shm done", DeBug) << "shmid : " << shmid << endl;// 5.删除共享内存，IPC_RMID即便是有进程和当下的shm挂接，依旧删除共享内存n = shmctl(shmid, IPC_RMID, nullptr);if (n == -1){perror("shmctl");exit(4);}Log("delete shm done", DeBug) << "shmid : " << shmid << endl;return 0;
}

注：
（1）在服务端先创建一个管道文件
在这里插入图片描述
（2）在读取共享内存中的数据前，先读取管道数据，看客户端是否响应；

shmClient.cc

#include "comm.hpp"int main()
{// 客户端也获取keykey_t key = ftok(PATH_NAME, PROJ_ID);if (key < 0){Log("creat key failed", Error) << "client key : " << key << endl;exit(1);}Log("creat key done", DeBug) << "client key : " << key << endl;// 获取共享内存int shmid = shmget(key, SHM_SIZE, 0);if (shmid == -1){Log("creat shm failed", Error) << "client key : " << key << endl;exit(2);}Log("creat shm done", DeBug) << "client key : " << key << endl;// 挂接共享内存char *shmaddr = (char *)shmat(shmid, nullptr, 0);if (shmaddr == nullptr){Log("attach shm failed", Error) << "client key : " << key << endl;}Log("attach shm done", DeBug) << "client key : " << key << endl;// 使用//client将共享内存看作一个char类型的buffer//客户端从键盘读取消息，直接读到共享内存中//使用管道进行访问控制int fd = OpenFIFO(FIFO_NAME, WRITE);while (true){ssize_t s = read(0, shmaddr, SHM_SIZE - 1);if(s > 0){shmaddr[s - 1] = 0;Signal(fd);//向管道写入数据if(strcmp(shmaddr, "quit") == 0)//读到quit，客户端退出{break;}}}CloseFIFO(fd);// 去关联int n = shmdt(shmaddr);if (n == -1){perror("shmdt");exit(3);}Log("detach shm done", DeBug) << "client key : " << key << endl;// client不需要删除shmreturn 0;
}

注：
（1）在向共享内存写入数据前，先向管道写入信号，表明客户端准备写入数据，唤醒服务端：
在这里插入图片描述

运行结果：
当运行服务端，但是客户端未响应时，服务端会等待客户端响应，进程阻塞；
在这里插入图片描述
当客户端响应时，服务端会被唤醒，读取共享内存中的数据：

退出：

二、信号量（概念理解）

1.概念

基于对共享内存的理解：
为了让进程间通信，让不同的进程之间，看到同一份资源，我们之前讲的所有的进程间通信都是基于这种方式；
而让不同的进程看到同一份资源，比如共享内存，也带来了一些时序问题，会造成数据的不一致
概念
（1）临界资源：多个进程（执行流）看到的公共的一份资源；
（2）临界区：自己的进程，访问临界资源的代码；
（3）互斥：为了更好的进行临界区的维护，可以让多执行流在任何时刻，都只能有一个进程进入临界区；
（4）原子性：要么不做，要么做完，没有中间状态；

2.信号量

我们平常看电影前，会先买票，电影院中的座位就相当于资源，当你买了票，这个座位就真正属于你，买票的本质就是对座位的预定机制；
对于进程来说，访问临界资源中的一部分，不能让进程直接去使用临界资源，需要先申请信号量；
信号量的本质是一个计数器；

申请信号量：
（1）申请信号量的本质，就是让信号量技术器 - -；
（2）申请信号量成功，临界资源内部，一定给进程预留了需要的资源，申请信号量的本质就是对临界资源的一种预定机制；
释放信号量：
释放信号量就是将计数器++；

如果将信号量计数器设为全局变量（整数n，存放在共享内存），让多个进程看到同一个全局变量，大家都能够进行信号量的申请，这样是不行的；
因为CPU在执行n++这个指令的时候，其实执行了三条语句：
（1）将内存中的数据加载到CPU内的寄存器（读指令）；
（2）n–（执行指令）；
（3）将CPU修改完毕的值再写入内存（写指令）；
而执行流在执行的时候，在任何时刻都是能被切换的；
例如：
如果信号量刚开始是5，client在申请信号量的时候，第一步就被切换了，寄存器里的数据保存为上下文数据，
由server申请信号量，如果server将信号量减到2了，此时server被切换，client回来
client回来的时候就会将上下文数据恢复，将信号量恢复为5，再申请信号量，这时信号量就变为了4；

寄存器只有一套，被所有执行流共享，但是寄存器内的数据，属于每一个执行流，属于该执行流的上下文数据；
这样设计，会导致信号量是不安全的；
因此，申请和释放信号量这两个操作，必须是原子的；
在这里插入图片描述