进程间通信——共享内存

system V进程间通信：OS特地设计的方式

一、共享内存

1.共享内存：以传送数据为目的

物理地址映射到进程的地址空间中（映射本质：修改页表，虚拟地址空间中开辟空间，用的是系统接口，完成开辟空间，建立映射，开辟虚拟地址，返回给用户都是OS操作）

2.共享内存建立的过程：

开始通信：
（1）申请共享内存（物理内存已经开辟完成）；shmget函数
（2）将共享内存挂接到地址空间（挂接：建立映射关系）
释放资源的过程：
（3）用完后，去关联共享内存（修改页表，取消映射关系）
（4）释放共享内存（内存归还给系统）

3.如何保证共享内存是唯一的？如何保证不同的进程看到的是同一份资源？

（1）共享内存需要唯一标识：(这个int，共享内存句柄，在用户层标识共享内存，使用接口访问共享内存 )int shmget(key_t key,size_t size,int shmflg); key会填充
（2）IPC资源的唯一性（key）；
（3）IPC_CREAT：如果共享内存存在，直接放回该共享内存，如果不存在，再创建；一定会获得一个shm,调用成功的情况下，无法确认是否是个全新的shm(shmflg)
（4）IPC_EXCL：不能单独使用，经常与IPC_CREAT组合使用，IPC_CREAT|IPC_EXCL（如果共享内存不存在，则创建；如果存在，出错返回；调用成功，一定会获得一个全新的shm）
（5）pathname与proj_id当作数据，用算法生成了一个序号id：
得到key值：key_t ftok(const char*pathname,int proj_id); pathname:工程名称，即路径名；proj_id：工程id，数据

4.创建共享内存：

== ipcs 查看进程间通信资源 ipcrm 删除进程间通信资源==

-m 针对共享内存的操作

-q 针对消息队列的操作

-s 针对消息队列的操作

-a 针对所有资源的操作

（1）查看共享内存：ipcs -m

a.shm的生命周期是随内核的，进程不主动删除或者用命令删除，共享内存会一直存在，直到关机重启；
b.system v IPC周期也是如此；
c.IPC资源一定是由内核提供并维护的；

(2) 删除共享内存命令：ipcrm -m 10（10是shmid）
共享内存的增删改：
int shmctl(int shmid,int cmd,struct shmid_ds *buf);
shmid：操作哪一个文件
cmd:IPC_RMID(移除)

（3）具体过程：
1.创建shm
shmget
2.关联进程:
void *shmat(int shmid,const void *shmaddr(地址，一般为NULL，OS设置),int shmflg（设置某些属性，如：读）);
返回值：对应共享内存的映射到进程地址空间中的虚拟地址的起始地址
3.取消关联
int shmdt(const void * shaddr); //shaddr为shmat的返回值
4.删除shm
shmctl

server.c文件

#include<stdio.h>
#include<unistd.h>
#include<sys/ipc.h>
#incldue<sys/shm.h>
#include<sys/types.h>

#define SIZE 4096
#define PATHNAME "/home/sxl/Linux/shm"
#define PROJ_ID 0x66

int main()
{
	key_t k = ftok(PATHNAME,PROJ_ID);  //生成一个key值
	if(k < 0){
		perror("ftok");
		return 1;
	}
	printf("k:%x\n",k);
	int shmid = shmget(k,SIZE,IPC_CREAT|PIC_EXECL|0666);  //给权限666，不然下面会挂接失败
	if(shmid < 0){
		perror("shmget");
		return 2;
	}
 	
 	printf("shmid:%d\n",shmid);
	
	printf("attatch begin!\n");
	sleep(5);
	char *men = shmat(shmid,NULL,0);  //挂接
	if()
	printf("attatch end!,%d\n",(int)mem);  //若挂接失败，则返回-1
	sleep(5);

    printf("dettach begin!\n");
    sleep(5);
	shmdt(mem);
	printf("dattach end!\n");  
	sleep(5);
  
    shmctl(shmid,IPC_RMID,NULL);   //移除共享内存
}

server.c文件

#include<stdio.h>
#include<unistd.h>
#include<sys/ipc.h>
#incldue<sys/shm.h>
#include<sys/types.h>

#define SIZE 4096
#define PATHNAME "/home/sxl/Linux/shm"
#define PROJ_ID 0x66

int main()
{
	key_t k = ftok(PATHNAME,PROJ_ID);  //生成一个key值
	if(k < 0){
		perror("ftok");
		return 1;
	}
	printf("k:%x\n",k);
	int shmid = shmget(k,SIZE,IPC_CREAT|PIC_EXECL|0666);  //给权限666，不然下面会挂接失败
	if(shmid < 0){
		perror("shmget");
		return 2;
	}
 	
 	printf("shmid:%d\n",shmid);
	
	char *mem = shmat(shmid,NULL,0);  //挂接
	while(1)
	{
		printf("client:%s\n",mem);
		sleep(1);
	}

  	shmdt(mem);
   // shmctl(shmid,IPC_RMID,NULL);   //移除共享内存
}

client.c文件

#include "comm.h"
int main()
{
	key_t k = ftok(PATHNAME,PROJ_ID);
	if(k < 0)
	{
		perror("ftok error!");
		return 1;
	}
	printf("%x\n",k);
	int shmid = shmget(k,SIZE,IPC_CREAT);
	if(shmid < 0)
	{
		perror("shmget error");
		return 2;
	}
	//挂接
	char *mem = shmat(shmid,NULL,0);
	int i = 0;
	while(1)
	{
		mem[i] = 'A'+i;
		sleep(1);
		i++;
		mem[i] = '\0';  //代表字符串结尾
	}
	shmdt(mem); //取消挂接
	return 0;
	
}

注意：
（1）挂接数2为2，则两个进程看到的是同一份资源
（2）共享内存是按照一页一页数据给的（4096bytes）
（3）client.c需要同一个key值，保证看到的是同一个文件

（4）读写共享内存的时候，没有使用OS接口

5.共享内存特点：

（1）速度最快，拷贝少（相比管道，少了两次拷贝过程，写入与读取）
（2）不提供任何保护机制（互斥与同步，利用信号量保证互斥）

6.共享内存相关数据结构

key：在内核层面上，多个进程之间，区分共享内存唯一性的方式
shmid：在进程内部，区分某一个IPC资源

7.例子：使用代码创建一个共享内存， 支持两个进程进行通信， 进程A 向共享内存当中写 “i am process A”， 进程B 从共享内存当中读出内容，并且打印到标准输出

A进程

#include"comm.h"

int main()
{
  key_t k = ftok(PATH,PROJ_ID);  //先获得一个key值
  if(k < 0)
  {
    perror("ftok error!");
    return 1;
  }
  int shmid = shmget(k,SIZE,IPC_CREAT);
  if(shmid < 0)
  {
    perror("shmget error");
    return 2;
  }

  //挂接
  char *mem = shmat(shmid,NULL,0);
  while(1)
  {

    printf("Please enter:");
   // bzero(mem,SIZE);
 // strcpy(mem,"I am process A!\n");
    fgets(mem,SIZE,stdin);
  }
  shmdt(mem);  //取消挂接
  return 0;
}

B进程

#include"comm.h"

int main()
{
  key_t k = ftok(PATH,PROJ_ID);
  if(k < 0)
  {
    perror("ftok error");
    return 1;
  }

  int shmid = shmget(k,SIZE,IPC_CREAT|IPC_EXCL|0666);
  if(shmid < 0)
  {
    perror("shmid error");
    return 2;
  }

  char *mem = shmat(shmid,NULL,0);
 
  while(1)
  {
    printf("A:%s\n",mem);
    sleep(3);
  }
  

 //printf("A:%s\n",mem);
  shmdt(mem);
  /*
  //分离共享内存和当前进程
  int	ret = shmdt(mem);
	if(ret < 0)
	{
		perror("shmdt");
		exit(1);
	}
	else
	{
		printf("deleted shared-memory\n");
	}
	*/
	//删除共享内存
//	shmctl(shmid, IPC_RMID, NULL);


  return 0;
}

comm.h

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<string.h>
#include<stdlib.h>


#define PATH "/home/sxl/code/Linux/homework/shm"
#define SIZE 4096
#define PROJ_ID 0x66

另外补充知识：

二、消息队列：以传送数据为目的

1.消息队列提供了一个从一个进程向另一个进程发送一块数据的方法
2.每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值
3.IPC资源必须被删除，否则不会自动清除，除非重启

三、信号量：保证进程的同步互斥设计的，属于通信范畴

信号量：保护临界资源
信号量本质：是一个计数器（信号量本身也是临界资源）
P V操作，必须保证原子性
P操作：申请信号量，计数器–
V操作：释放信号量，计数器++
PV具体讲解
原子性：要么操作了，要么没有

共享内存数据结构
key:在内核层面上，多个进程之间，区分共享内存的唯一方式
shmid：在进程内部，区分某一个IPC资源（用户层）