进程间通信—system v标准

System v标准的进程间通信包括共享内存，消息队列和信号量。我们着重介绍共享内存。

前面我们介绍了通信的前提是：不同进程能看到同一份内存资源。前面我们介绍的管道是借助了文件系统来让不同进程看到同一份资源，我们即将介绍的共享内存是依靠在内存中创建一个共享内存区实现

1.共享内存

1.1共享内存的原理

先在物理内存申请一块空间----》将内存地址和进程地址空间通过页表挂起----》进行通信------》未来不想通信时先取关联，再释放内存空间。

与malloc或者new开辟的空间的区别：本质上都是再内存开辟一块空间，然后将其和进程挂起。但是malloc和new只能与一个进程建立联系，而共享内存是专门用来ipc通信的。

1.2接口认识

1.2.1shmget（创建或获取共享内存）与ftok（获取key）

1.2.2shmat(shmattach将共享内存和进程挂接) 与shmdt（将共享内存和进程去关联）

值得注意的是shmat失败返回（void*） -1，在一般的机器上是64位，因此将返回值不能强转为int，应该强转为longlong

1.2.3shmctl（shmcontrol 对共享内存进行控制）

1.3shell命令查看ipc资源

ipcs -m/-q/-s 分别查看共享内存，消息队列，信号量资源

ipcrm -m shmid 删除指定id的共享内存资源

1.4system v标准的ipc资源特征

1️⃣共享内存资源随OS，不随进程

2️⃣所有进程间通信中最快，可以直接写在内存中，再从内存中读取不需要额外的数据拷贝

3️⃣没有数据同步和互斥，数据没有被保护起来

1.5shm大小问题

系统是以4kb为单位划分内存为page，因此shm大小建议是4kb的整数倍，如果不是整数倍OS会申请整数倍的内存资源，但是你只能用你实际的填写的大小。

示例代码：client与server进程通信：

comm.hpp

cpp 复制代码

#pragma once
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<unistd.h>

#define MAX_SIZE 4096
#define PATH_NAME "."
#define PROJ_ID 0x55

//利用shm实现进程间通信1.创建共享内存（获取共享内存） 2.将shm与进程挂起 3.将shm与进程取消挂起 4.回收共享内存

key_t getkey(){
    int key = ftok(PATH_NAME,PROJ_ID);
    if(key == -1){
        std::cerr<<"ftok filed"<<strerror(errno)<<std::endl;
        exit(1);
    }
    return key;
}

int getshm(key_t key,int flags){
    int shm_id  = shmget(key,MAX_SIZE,flags);
    if(shm_id == -1){
        std::cerr<<"shmget filed"<<strerror(errno)<<std::endl;
        exit(2);
    }
    return shm_id;
}

int createshm(key_t key){
    int shm_id = getshm(key,IPC_CREAT|IPC_EXCL|0600);
    return shm_id;
}

int getshm(key_t key){
    int shm_id = getshm(key,IPC_CREAT);
    return shm_id;
}

void* shmattach(int shmid){
    void* shmaddr = shmat(shmid,NULL,0);
    if((long long) shmaddr == -1){
        std::cerr<<"shmat filed"<<strerror(errno)<<std::endl;
        exit(3);
    }
    return shmaddr;
}

void shmdetach(const char* shmaddr){
    int r = shmdt(shmaddr);
    if(r == -1){
        std::cerr<<"shmdt filed"<<strerror(errno)<<std::endl;
        exit(4);
    }
}

void shmdelete(int shmid){
    int r = shmctl(shmid,IPC_RMID,NULL);
    if(r == -1){
        std::cerr<<"shmdelete filed"<<strerror(errno)<<std::endl;
        exit(5);
    }
}

server.cpp

cpp 复制代码

#include"Comm.hpp"


//利用shm实现进程间通信1.创建共享内存（获取共享内存） 2.将shm与进程挂起 3.将shm与进程取消挂起 4.回收共享内存
int main(){
    key_t key = getkey(); //获取key
    int shm_id = createshm(key); //创建shm
    char* shm_addr = (char*)shmattach(shm_id);//挂起

    //读
    while(true){
        std::cout<<shm_addr<<std::endl;
        sleep(1);
    }

    shmdetach(shm_addr);//取消挂起
    shmdelete(shm_id);//回收资源

    return 0;
}

client.cpp

cpp 复制代码

#include"Comm.hpp"

int main(){
    key_t key = getkey(); //获取key
    int shm_id = getshm(key); //获取shm
    char* shm_addr = (char*)shmattach(shm_id);//挂起
    //写
    const char* message = "我是客户端,我正在想服务端发信息";
    int cnt = 1;
    while(true){
        //TODO
        snprintf(shm_addr,MAX_SIZE,"%s[pid:%d][发送计数:%d]",message,getpid(),cnt++);
        sleep(1);
    }
    
    shmdetach(shm_addr);//取消挂起
    return 0;
}

2.消息队列

消息队列相较于共享内存解决了问题，消息队列通过自带同步机制、明确数据边界、控制数据流向和增强数据安全性等方式

3.信号量

信号量的本质上一个计数器，其用来表示公共资源数目的数据。

公共资源能被多个进程访问，我们也可以对公共资源进行划分：1️⃣作为整体使用2️⃣划分为一个个子资源使用。

我们引入信号量就是为了来对2️⃣情况进行合理的配置。实现对资源的数据保护。防止出现数据不一致问题

我们可以举一个简单的例子：电影院电影票的例子。信号量就相当于总共的票量，当被预约位置时票量就会减少，信号量就--。当取消预约时票量就会被释放，信号量就++。

当--信号量后我们就能对资源进行访问，当结束后就++信号量释放资源.对信号量的++，--属于原子操作，无需担心其数据不一致问题。

4.system V的管理（先描述，再组织）

无论是共享内存，消息队列或者信号量，其shmid_ds , msgid_ds或者semid_ds 其结构体中的第一个存储的都是ipc_perm结构体，我们可以将其ipc_perm结构体组织起来，因为结构体中的第一个成员地址在数字上和整个结构体的地址相同，因此我们只需要强转，就能访问整个结构体。实现了类似C++多态的访问方式。