共享内存
共享内存是SystemV标准进程间通信的一种，该标准还有消息队列和信号量，但下文主要介绍共享内存，然后在谈一下信号量的内容。SystemV标准的进程间通信可以看做单机版的进程间通信。
// 1. log.hpp
#pragma once
#include <iostream>
enum ErrLevel
{
lev_0,
lev_1,
lev_2,
lev_3,
lev_4
};
const std::string error[] = {
"err_0",
"err_1",
"err_2",
"err_3",
"err_4"
};
std::ostream& Log(const std::string& msg, int level)
{
std::cout << " | " << (unsigned int)time(0) << " | " << error[level] << " | " << msg << " |";
return std::cout;
}
// 2. comm.hpp
#pragma once
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <cstring>
using namespace std;
#include "log.hpp"
// key_t ftok(const char *pathname, int proj_id);
#define PATH_NAME "/home/zs/linux/testcpp"
#define PROJ_ID 0x20231118
// 共享内存的大小，最好是页(PAGE:4096)的整数倍
#define SHM_SIZE 4096
#define MODE 0666
#define FIFO_PATH "./fifo"
class FIFO
{
public:
FIFO()
{
if(0 != mkfifo(FIFO_PATH, MODE))
{
perror("mkfifo");
exit(1);
}
Log("create fifo success", lev_1) << endl;
}
~FIFO()
{
if(0 != unlink(FIFO_PATH))
{
perror("unlink");
exit(2);
}
Log("unlink fifo success", lev_2) << endl;
}
};
int openFIFO(const string& pathname, int flags)
{
int fd = open(pathname.c_str(), flags);
if(fd == -1)
{
perror("open");
exit(3);
}
return fd;
}
void Wait(int fd)
{
uint32_t i = 0;
ssize_t size = read(fd, &i, sizeof(i));
if(size == -1)
{
perror("Wait::read");
exit(4);
}
}
void Signal(int fd)
{
uint32_t i = 1;
ssize_t size = write(fd, &i, sizeof(i));
if(size == -1)
{
perror("Signal::write");
exit(5);
}
}
void closeFIFO(int fd)
{
close(fd);
}
创建共享内存使用shmget函数。
key：只有创建的时候用到key(key是调用ftok用算法形成的，标识了系统层上的唯一性)；大部分情况下用户访问共享内存用的还是shmid(shmget的返回值，它的使用类似文件描述符fd，标识了用户层上的唯一性)。
size：设置创建的共享内存的大小。
shmflg：
IPC_CREAT：单独使用，如果共享内存不存在，创建并返回；如果已经存在，获取并返回。IPC_EXCL：单独使用，没有意义。IPC_CREAT | IPC_EXCL：共同使用，如果共享内存不存在，创建并返回；如果已经存在，出错返回（如果返回成功，一定是一个全新的共享内存）。
创建共享内存之前key的生成由ftok接口完成。
ftok可以确保接收到相同的pathname和proj_id会使用算法生成相同的key。
而不同进程通过拿到相同的key值来看到同一份资源。
// 3. server.hpp
#include "comm.hpp"
// 程序在加载时，自动构建全局变量，自动调用fifo的构造函数，创建管道文件
// 程序退出时，全局变量会被析构，自动调用fifo的析构函数，删除管道文件
FIFO fifo;
void test()
{
// 通信的前置工作，让不同进程看到同一份资源(内存)
// 1.创建公共的key值
key_t key = ftok(PATH_NAME, PROJ_ID);
if(key == -1)
{
perror("ftok");
exit(1);
}
Log("server create key success", lev_1) << " server key: " << key << endl;
// 2.创建共享内存 -- 建议创建一个全新的共享内存
int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | MODE);
if(shmid == -1)
{
perror("shmget");
exit(2);
}
Log("server create shm success", lev_2) << " shmid: " << shmid << endl;
// 3.将共享内存挂接到自己的地址空间
char* shmaddr = (char*)shmat(shmid, nullptr, 0);
if((void*)shmaddr == (void*)-1)
{
perror("shmaddr");
exit(3);
}
Log("server attach shm success", lev_3) << " shmaddr: " << (void*)shmaddr << endl;
// 4.通信 -- 将共享内存看做字符串存储空间
// 关于共享内存的通信有两个结论：
// a.通信双方一方可以直接向共享内存写数据，另一方可以立刻看到写的数据
// 共享内存是所有进程间通信(IPC)速度最快的。因为它不需要过多的拷贝（表现就是不需要将数据给到操作系统）
// 共享内存映射进进程地址空间的共享区(在用户空间内)，所以不需要经过系统调用，可以直接访问，双方进程通信属于内存级的读和写。
// b.共享内存缺乏访问控制，会引起并发问题
// 此处采用管道的访问控制功能，来对共享内存进行一定的访问控制
int fd = openFIFO(FIFO_PATH, O_RDONLY);
while(true)
{
Log("server wait...", lev_2) << endl;
Wait(fd);
cout << "server output: " << shmaddr << endl;
if(strcmp(shmaddr, "quit") == 0)
{
cout << "client quit, then server quit" << endl;
break;
}
// sleep(1);
}
closeFIFO(fd);
// sleep(10);
// 5.将共享内存从地址空间中祛关联
int dt = shmdt(shmaddr);
if(dt == -1)
{
perror("shmdt");
exit(4);
}
Log("server detach shm success", lev_4) << endl;
// 6.删除共享内存 -- IPC_RMID: 即使当前还有进程和shm挂接，依旧会删除shm
int ipcrm = shmctl(shmid, IPC_RMID, nullptr);
if(ipcrm == -1)
{
perror("shmctl");
exit(5);
}
Log("server rm shm success", lev_1) << endl;
}
共享内存的提供者是操作系统，当进程运行结束时，共享内存是还存在着的，其生命周期是随操作系统的。共享内存有两种删除方式，一是手动删除，二是利用代码调用接口删除。
可以调用shmctl接口进行删除。
cmd：填写删除指令IPC_RMID
buf：是用于描述共享内存结构的结构体指针，使用buf可以对共享内存的结构进行更改。
这里可以引出对共享内存的重新理解：共享内存 = 共享内存块 + 对应的共享内存的内核数据结构。
操作系统为了管理大量的共享内存，需要先描述再组织，进行管理。
buf所指向的共享内存的结构体。
共享进程创建好后，进程要访问共享进程还需要对其进行挂接（将共享内存映射进进程所在地址空间中）。
shmaddr：除非自己特别清楚要将共享内存挂接在什么位置，否则nullptr让系统自己处理。
// 4. client.cpp
#include "comm.hpp"
void test()
{
// 1.获取key
Log("client pid is:", lev_0) << " " << getpid() << endl;
key_t key = ftok(PATH_NAME, PROJ_ID); // key_t -- int
if(key == -1)
{
perror("ftok");
exit(1);
}
Log("client create key success", lev_1) << " client key: " << key << endl;
// 2.获取共享内存
int shmid = shmget(key, SHM_SIZE, IPC_CREAT);
if(shmid == -1)
{
perror("shmget");
exit(2);
}
Log("client get shm success", lev_2) << " shmid: " << shmid << endl;
// 3.将共享内存挂接到自己的地址空间
char* shmaddr = (char*)shmat(shmid, nullptr, 0);
if((void*)shmaddr == (void*)-1)
{
perror("shmaddr");
exit(3);
}
Log("client attach shm success", lev_3) << " shmaddr: " << (void*)shmaddr << endl;
// 4.通信
int fd = openFIFO(FIFO_PATH, O_WRONLY);
while(true)
{
write(1, "client input: ", strlen("client input: "));
ssize_t size = read(0, shmaddr, SHM_SIZE);
if(size == -1)
{
perror("read");
exit(5);
}
shmaddr[size - 1] = '\0';
Signal(fd);
if(strcmp(shmaddr, "quit") == 0) break;
}
closeFIFO(fd);
// 5.祛关联
int dt = shmdt(shmaddr);
if(dt == -1)
{
perror("shmdt");
exit(4);
}
Log("client detach shm success", lev_4) << endl;
}
信号量
这里不谈消息队列的问题，但消息队列的接口使用和共享内存都是相似的。
临界资源：多个进程(执行流)看到的一份公共的资源。
临界区：进程里，访问临界资源的代码部分。
由临界资源和临界区的概念可以知道，多个进程(执行流)，同时运行时会互相干扰，主要是不加保护地访问了同一份资源(临界资源)。而再分临界区，多个进程(执行流)是互不影响的。
互斥：为了更好地进行临界资源的保护，可以让多个进程(执行流)在任何时刻，只能有一个进入临界区。
原子性：要么不做，要么做完，没有中间状态。
信号量的出现让任何一个进程要访问临界资源时，不能直接访问，而是要先申请信号量（这里可以看出信号量也属于临界资源，可以被多个进程看到）。
信号量本质是一个计数器，申请信号量的本质就是让计数器减一。
只要申请信号量成功，在临界资源内部一定会预留有该进程要访问的资源。
而申请信号量的本质，是对临界资源的一种预定机制。
申请信号量(P操作)和释放信号量(V操作)必须是原子的。
