目录
1.system V共享内存
共享内存区是最快的IPC(进程间通信)形式。一旦这样的内存映射到共享它的进程地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。
共享内存区它是指多个进程可以访问和共享同一块内存区域，从而实现进程间的数据交换和通信。共享内存区通常被认为是最快的IPC形式，因为它避免了数据的复制和传输，进程可以直接在共享的内存区域中读写数据，速度较快。
system V的特性：
- 共享内存没有同步互斥之类的保护机制
- 共享内存是所有进程间通信中，速度最快的
- 共享内存内部的数据由用户自己维护
2.共享内存数据结构
进程间通信的本质：先让不同的进程，看到同一份资源
操作系统要不要管理所有的共享内存？要，先描述再组织
1. 防止冲突
如果没有操作系统统一管理共享内存，多个进程可能会同时尝试访问同一块内存区域，从而引发数据竞争或不一致的情况。这种情况下可能导致程序崩溃甚至整个系统不稳定。
2. 保护隐私与安全
操作系统通过权限控制机制确保只有授权的进程能够访问特定的共享内存区域。这不仅有助于维护不同应用程序之间的隔离性，还增强了整体系统的安全性。
3. 优化性能
通过虚拟内存技术和工作集理论的支持，操作系统可以更高效地调度和分配共享内存给各个需要它的进程。这样不仅可以减少不必要的物理内存占用，还能提升多任务环境下的响应速度和吞吐量。
4. 简化编程模型
对于开发者而言，拥有一个由操作系统提供并保障的一致性和可靠性高的共享内存抽象层是非常重要的。它可以让程序员专注于业务逻辑而非底层复杂的同步细节。
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 */
unsigned short shm_cpid; /* PID of creator */
unsigned short shm_lpid; /* PID of last operator */
unsigned short shm_nattch; /* Number 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 */
};
3.共享内存函数
ftok函数
功能：生成一个key
首先，我们需要谈谈 什么是key
- key是一个数字，这个数字是几不重要，关键在于它必须在内核中具有唯一性，能够让不同的进程进行唯一性标识
- 第一个进程可以通过key创建共享内存，第二个之后的进程，只要拿着同一个key就可以和第一个进程看到同一个共享内存
- 对于一个已经创建好的共享内存key在哪？key在共享内存的描述对象中
- 第一次创建的时候必须有一个key了
- key--类似路径--唯一
参数
pathname：一个已存在的文件路径名，函数会依据该文件的inode号参与生成键值。要确保调用ftok的进程对该文件有读权限
proj_id：一个整数，通常使用0 - 255（8 位）范围内的值，作为项目标识符进一步确保生成键值的唯一性
返回值：key值
shmget函数
功能：用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);
参数
key:这个共享内存段名字
size:共享内存大小(单位是字节)
shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1
shmat函数
功能：将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数
shmid: 共享内存标识
shmaddr:指定共享内存出现在进程内存地址的位置
shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1说明：
shmaddr为NULL，核心自动选择一个地址
shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr -
(shmaddr % SHMLBA)
shmflg=SHM_RDONLY，表示连接操作用来只读共享内存
shmdt函数
功能：将共享内存段与当前进程脱离
原型
int shmdt(const void *shmaddr);
参数
shmaddr: 由shmat所返回的指针
返回值：成功返回0；失败返回-1
注意：将共享内存段与当前进程脱离不等于删除共享内存段
shmctl函数
功能：用于控制共享内存
原型
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数
shmid:由shmget返回的共享内存标识码
cmd:将要采取的动作（有三个可取值）
buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值：成功返回0；失败返回-1
cmd：控制命令，常用值如下：
IPC_RMID：标记共享内存段为 “待删除” 状态（实际删除发生在所有进程断开连接后）。IPC_STAT：将共享内存的状态信息复制到 buf中。IPC_SET：使用中的buf值更新共享内存的权限和所有者信息。IPC_INFO：获取系统范围内共享内存的限制和状态（需 Linux 特定参数）。注意：
共享内存的生命周期是随内核的！用户不主动关闭，共享内存会一直存在
除非内核重启(用户释放)
ipcs -m
指令用于显示系统中当前存在的共享内存段的详细信息。通过运行这个指令，可以查看系统中的共享内存段的标识符、大小、权限等信息。这对于诊断和监视系统中共享内存的使用情况非常有用。
4.实例代码：
makefile
.PHONY:all
all:processa processb
processa:processa.cc
g++ -o $@ $^ -g -std=c++11
processb:processb.cc
g++ -o $@ $^ -g -std=c++11
.PHONY:clean
clean:
rm -f processa processb
comm.hpp
#ifndef __COMM_HPP__
#define __COMM_HPP__
#include <iostream>
#include<string>
#include<cstdlib>
#include<cstring>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<sys/stat.h>
#include "log.hpp"
using namespace std;
Log log;
//共享内存的大小一般建议是4096的整数倍
//4097，实际上操作系统给你的是4096*2的大小
const int size = 4096;
const string pathname="/home/xchild";
const int proj_id = 0x6666;
key_t GetKey()
{
key_t k = ftok(pathname.c_str(), proj_id);
if(k < 0)
{
log(Fatal,"ftok error: %s",strerror(errno));
exit(1);
}
log(Info, "ftok success, key is : 0x%x",k);
return k;
}
int GetShareMemHelper(int flag)
{
key_t k = GetKey();
int shmid = shmget(k, size, flag);
if(shmid < 0)
{
log(Fatal,"create share memory error: %s",strerror(errno));
exit(2);
}
log(Info,"create share memory success, shmid: %d",shmid);
return shmid;
}
int CreateShm()
{
return GetShareMemHelper(IPC_CREAT);
}
int GetShm()
{
return GetShareMemHelper(IPC_CREAT);
}
#define FIFO_FILE "./myfifo"
#define MODE 0664
enum{
FIFO_CREATE_ERR = 1,
FIFO_DELETE_ERR,
FIFO_OPEN_ERR
};
class Init
{
public:
Init()
{
//创建管道
int n = mkfifo(FIFO_FILE, MODE);
if(n == -1)
{
perror("mkfifo");
exit(FIFO_CREATE_ERR);
}
}
~Init()
{
int m = unlink(FIFO_FILE);
if(m == -1)
{
perror("unlink");
exit(FIFO_DELETE_ERR);
}
}
};
#endifprocessa.cc
#include"comm.hpp"
extern Log log;
int main()
{
Init init;
int shmid = CreateShm();
char *shmaddr = (char*)shmat(shmid,nullptr,0);
//ipc code 在这里！！
//一旦有人把数据写入到共享内存，其实我们立马能看到了
//不需要经过系统调用，直接就能看到数据了
int fd = open(FIFO_FILE, O_RDONLY);//等待写入方打开之后，自己才会打开文件，向后执行，open阻塞了
if(fd < 0)
{
log(Fatal,"error string: %s, error code: %d", strerror(errno),errno);
exit(FIFO_OPEN_ERR);
}
struct shmid_ds shmds;
while(true)
{
char c;
ssize_t s = read(fd, &c, 1);
if(s == 0)break;
else if(s < 0)break;
cout << "client say@ " <<shmaddr <<endl;//直接访问共享内存
sleep(1);
shmctl(shmid,IPC_STAT,&shmds);
cout<<"shm size: "<<shmds.shm_segsz<<endl;
cout<<"shm nattch: "<<shmds.shm_nattch<<endl;
printf("shm key: 0x%x\n", shmds.shm_perm.__key);
cout<<"shm mode: "<<shmds.shm_perm.mode<<endl;
}
shmdt(shmaddr);
shmctl(shmid, IPC_RMID,nullptr);
close(fd);
return 0;
}processb.cc
#include "comm.hpp"
int main()
{
int shmid = GetShm();
char *shmaddr = (char*)shmat(shmid,nullptr,0);
int fd = open(FIFO_FILE,O_WRONLY);//等待写入方打开之后，自己才会打开文件，向后执行，open阻塞了
if(fd < 0)
{
log(Fatal,"error string: %s, error code: %d",strerror(errno),errno);
exit(FIFO_OPEN_ERR);
}
//一旦有了共享内存，挂接到自己的地址空间中，你直接把他当作你的内存空间来用即可
//不需要调用系统调用
//ipc code
while(true)
{
cout<<"Please Enter@ ";
fgets(shmaddr,4096,stdin);
write(fd,"c",1);//通知对方
}
shmdt(shmaddr);
close(fd);
return 0;
}log.hpp
#pragma once
#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#define SIZE 1024
#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4
#define Screen 1
#define Onefile 2
#define Classfile 3
#define LogFile "log.txt"
class Log
{
public:
Log()
{
printMethod = Screen;
path = "./log/";
}
void Enable(int method)
{
printMethod = method;
}
std::string levelToString(int level)
{
switch (level)
{
case Info:
return "Info";
case Debug:
return "Debug";
case Warning:
return "Waring";
case Error:
return "Error";
case Fatal:
return "Fatal";
default:
return "None";
}
}
void printLog(int level, const std::string &logtxt)
{
switch (printMethod)
{
case Screen:
std::cout << logtxt << std::endl;
break;
case Onefile:
printOneFile(LogFile, logtxt);
break;
case Classfile:
printClassFile(level, logtxt);
break;
}
}
void printOneFile(const std::string &logname, const std::string &logtxt)
{
std::string _logname = path + logname;
int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
if (fd < 0)
return;
write(fd, logtxt.c_str(), logtxt.size());
close(fd);
}
void printClassFile(int level, const std::string &logtxt)
{
std::string filename = LogFile;
filename += ".";
filename += levelToString(level);
printOneFile(filename, logtxt);
}
~Log()
{
}
void operator()(int level, const char *format, ...)
{
time_t t = time(nullptr);
struct tm *ctime = localtime(&t);
char leftbuffer[SIZE];
snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),
ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
va_list s;
va_start(s, format);
char rightbuffer[SIZE];
vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
va_end(s);
// 格式：默认部分+自定义部分
char logtxt[SIZE * 2];
snprintf(logtxt, sizeof(logtxt), "%s %s\n", leftbuffer, rightbuffer);
printLog(level, logtxt);
}
private:
int printMethod;
std::string path;
};