Linux之systemV共享内存方式

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

#ifndef __COMM_HPP__
#define __COMM_HPP__
China编程
#include <IOStream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/stat.h>

#define FIFO_FILE "./myfifo"
#define MODE 0664

enum
{
    FIFO_CREATE_ERR = 1,
    FIFO_DELETE_ERR,
    FIFO_OPEN_ERR,
    FIFO_READ_ERR
};

using namespace std;

Log log;

const int size = 4096; 
const string pathname="/home/slm";
const int proj_id = 0x6667;

//封装一个获取Key值的函数
key_t GetKey()
{
	//使用ftok函数获取key值
    key_t k = ftok(pathname.c_str(), proj_id);
    if(k < 0)
    {
        exit(1);
    }
    //返回生成的key值
    return k;
}
//封装一个建立共享内存区的函数
int GetShareMemHelper(int flag)
{
	//调用获取key值，然后在物理内存上申请共享内存
    key_t k = GetKey();
    int shmid = shmget(k, size, flag);
    if(shmid < 0)
    {
        exit(2);
    }
	//返回shmid
    return shmid;
}
//用于创建一个新的共享内存段，如果指定的共享内存段已经存在，函数会失败
int CreateShm()
{
    return GetShareMemHelper(IPC_CREAT | IPC_EXCL | 0666);
}
//用于获取一个共享内存段，如果指定的共享内存段不存在，函数会创建一个新的共享内存段；如果已经存在，则直接返回该共享内存段的标识符
int GetShm()
{
    return GetShareMemHelper(IPC_CREAT); 
}

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);
        }
    }
};
#endif

#include "comm.hpp"

extern Log log;

int main()
{
	//创建管道
    Init init;
    //调用 CreateShm 函数创建一个共享内存段，并返回该共享内存段的标识符shmid
    int shmid = CreateShm();
    //调用 shmat 函数将共享内存段附加到当前进程的地址空间，shmid 是共享内存段的标识符
    //nullptr 表示让系统自动选择附加地址，0 表示默认附加标志
    //返回值是共享内存段在进程地址空间中的起始地址，将其强制转换为char*类型并赋值给shmaddr
    char *shmaddr = (char*)shmat(shmid, nullptr, 0);
    //以只读模式打开命名管道文件FIFO_FILE，由于是以只读模式打开，该操作会阻塞
    //直到有其他进程以写模式打开同一个命名管道
    int fd = open(FIFO_FILE, O_RDONLY); 
    if (fd < 0)
    {
        exit(FIFO_OPEN_ERR);
    }
    //定义shmds用于存储共享内存段的状态信息
    struct shmid_ds shmds;
    while(true)
    {
	//定义一个字符变量c，调用read函数从命名管道文件描述符fd中读取1个字节的数据到c中
	//并将实际读取的字节数存储在s中，如果能读取到说明通信进程给我们发信号了，有内容
	//那我们就读取共享内存部分
        char c;
        ssize_t s = read(fd, &c, 1);
        if(s == 0) break;
        else if(s < 0) 
        {
            exit(FIFO_READ_ERR);
        }
		//可以直接通过指针访问共享内存
        cout << "client say@ " << shmaddr << endl; 
        sleep(1);
		//调用shmctl函数，使用IPC_STAT命令获取共享内存段的状态信息，并将其存储在shmds结构体中
		//然后将结构体shmds部分信息打印出来
        shmctl(shmid, IPC_STAT, &shmds);
    python    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函数，使用IPC_RMID命令将共享内存段标记为待删除状态
    //当所有附加进程都分离后，系统会自动删除该共享内存段
    shmctl(shmid, IPC_RMID, nullptr);
    close(fd);
    return 0;
}

#include "comm.hpp"

int main()
{
	//调用GetShm函数获取一个共享内存段的标识符shmid
	//在参数相同、无特殊情况的情况下，shmid也相同
    int shmid = GetShm();
    char *shmaddr = (char*)shmat(shmid, nullptr, 0);

    int fd = open(FIFO_FILE, O_WRONLY); 
    if (fd < 0)
    {
        exit(FIFO_OPEN_ERR);
    }
    // 一旦有了共享内存，挂接到自己的地址空间中，直接把他当成你的内存空间来用即可
    // 不需要调用系统调用接口
    while(true)
    {
        cout << "Please Enter@ ";
        fgets(shmaddr, 4096, stdin);
        //在管道写入一个字符来通知服务器共享内存有新数据
        write(fd, "c", 1); 
    }
	//调用shmdt函数将共享内存段从当前进程的地址空间分离，释放相关的资源
    shmdt(shmaddr);
    close(fd);
    return 0;
}