【LInux】进程间通信（共享内存）

system V共享内存

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据

共享内存是允许有多个shm存在的，而shm并不是简单的在内存上获取一块空间就结束了，他也是需要管理的因为有多块shm，共享内存=共享内存的属性（struct）+空间

shmget（创建共享内存）

先来介绍shmget的第二个参数是决定开辟共享内存空间的，
第三个参数当输入IPC_CREAT时，就是如果没有共享内存就创建共享内存，要是有的话就获取已经存在的共享内存并返回
IPC_EXCL是不能单独使用的，要通过和IPC_CREAT联合使用
IPC_CREAT | IPC_EXCL它的意思是如果没有共享内存就创建共享内存，要是有的话就出错返回，它要是成功的话就创建新的共享内存。
而它的第一个参数是由ftok决定的，ftok的返回值就是shmget的第一个参数，下面介绍一下ftok。

ftok（key）

两个完全不相关的进程是通过ftok的值实现共用同一个文件的，ftok的两个参数是两个进程之间约定好的值（自己定义保证双方是相同的），并且得到唯一的ftok值，一个进程创建ftok值，并将它放到要使用的共享内存（struct shm）当中，之后另一进程是通过该值去找这个共享内存，也就实现了共享内存。

ipcs指令

ipcs 命令用于查看 Linux 进程间通信设施的状态，包括消息列表、共享内存和信号量的信息。

ipcs -m   //只用于查看共享内存
ipcrm -m

共享内存在使用结束后会自己销毁吗？
并不会，当我们下次在创建新的共享内存（ftok相同）时候会发现是失败的（报错），所以也就证明了并不会销毁。所以需要人为的去销毁。ipcrm -m shmid。共享内存的生命周期并不跟随进程，而是跟随系统。

shmctl（销毁共享内存）

经上述问题使用shmctl进行销毁共享内存，它并不止之后销毁的功能还能查看1共享内存的属性。

shmat

创建完共享内存之后是需要进行链接就可以进行通信了。
它的返回值也就是共享内存开辟的首地址，然后映射到虚拟地址上。

代码

//comm.hpp
#ifndef _COMM_HPP_
#define _COMM_HPP_

#include<iostream>
#include<string>
#include<unistd.h>
#include<cerrno>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<string.h>
#include<cassert>
#include<sys/types.h>
#include<sys/stat.h>

using namespace std;

#define PATHNAME "."
#define PROJID 0x6666
#define gsize 4096

key_t GetKey()
{
    key_t k=ftok(PATHNAME,PROJID);
    if(k==-1)
    {
        cerr<<"errno:"<<errno<<strerror(errno)<<endl;
        exit(-1);
    }
    return k;
}

string ToHex(int a)
{
    char buffer[24];
    snprintf(buffer,sizeof(buffer),"0x%x",a);
    return buffer;
}

static int CreateShmHelp(int k,int size,int flag)
{
    int shmid=shmget(k,size,flag);
    if(shmid==-1)
    {
        cerr<<"errno:"<<errno<<strerror(errno)<<endl;
        exit(-1);
    }
    return shmid;
}

int CreateShm(int k,int size)
{
    umask(0);
    return CreateShmHelp(k,size,IPC_CREAT | IPC_EXCL | 0666);//获取一个新的共享内存
}

int GetShm(int k,int size)
{
    return CreateShmHelp(k,size,IPC_CREAT);
}

//链接共享内存
char* attachShm(int shmid)
{
    char *start = (char*)shmat(shmid, nullptr, 0);
    return start;
}
//断开链接共享内存
void detachShm(char *start)
{
    int n = shmdt(start);
    assert(n != -1);
    (void)n;
}

void DelShm(int shmid)//删除是需要权限的，但是我们以上面的方法创建的权限都是0
{                     //所以要想顺利删除使用sudo，或者在创建那里设置权限，也就是现在的样子
    int n=shmctl(shmid,IPC_RMID,nullptr);
    assert(n!=-1);
    (void)n;
}

#endif

//server.cc
#include"comm.hpp"

int main()
{
    key_t k=GetKey();
    cout<<"serverK:"<<ToHex(k)<<endl;

    int shmid=CreateShm(k,gsize);
    cout<<"serverS:"<<ToHex(shmid)<<endl;

    sleep(5);

    // struct shmid_ds ds;
    // int n=shmctl(shmid,IPC_STAT,&ds);

    // cout<<"perm:"<<ds.shm_perm.__key<<endl;
    // cout<<"pid:"<<ds.shm_cpid<<endl;
    //链接共享内存
    char* start = attachShm(shmid);
    //这里获取的start也就是共享内存开辟的首地址，然后映射到虚拟地址上

    //sleep(10);
    int n = 0;
    while(n <= 30)
    {
        cout <<"client -> server# "<< start << endl;
        sleep(1);
        n++;
    }   
    //断开连接
    detachShm(start);

    DelShm(shmid);
}

//client.cc
#include"comm.hpp"

int main()
{
    key_t k=GetKey();
    cout<<"clientK:"<<ToHex(k)<<endl;

    int shmid=GetShm(k,gsize);
    cout<<"clientS:"<<ToHex(shmid)<<endl;

    char* start = attachShm(shmid);
    int i = 0;
    while (i < 26)
    {
        start[i] = 'A' + i;
        i++;
        start[i] = 0;
        sleep(1);
    }

    //sleep(10);
    //断开连接
    detachShm(start);
}

//makefile
.PHONY:all
all:server client
server:server.cc
	g++ -o $@ $^ -std=c++11
client:client.cc
	g++ -o $@ $^ -std=c++11
	
.PHONY:clean
clean:
	rm -r server client
	

共享内存

共享内存是以page页来存储的单位是4KB，但是当我们需要4097个字节为什么，他就给了4097呢，原因是你需要多少它给多少，但是底层还是已经开辟了8KB

在通信的时候，没有使用任何接口？
一旦共享内存映射到进程的地址空间，该共享内存就直接被所有的进程直接看到了。
因为共享内存的这种特性，可以让进程通信的时候，减少拷贝次数，所以共享内存是所有进程通信速度最快的。
共享内存没有任何的保护机制（同步互斥）？管道是通过系统接口进行通信的（read,write内就有保护机制，确保有没有数据等），而共享内存是直接通信

消息队列

消息队列就是将两个进程需要给对方的信息链接到队列上，然后在队列当中遍历去找对方的信息，因为也是会存在多个队列，所以也是需要用结构体进行组织起来，让其更好的管理。


上面的图片是创造消息队列和销毁消息队列（也可以查看msg属性）
下图的两个接口对应共享内存当中的链接和断开，这里是发送消息和接收消息

信号量