目录

一.共享内存实现进程间通信的原理

二.管理共享内存的数据结构

三.共享内存函数

四.实现进程间通信

---

接博客：进程间通信之管道

一.共享内存实现进程间通信的原理

        共享内存实际是操作系统在实际物理内存中开辟的一段内存。

        共享内存实现进程间通信，是操作系统在实际物理内存开辟一块空间，一个进程在自己的页表中，将该空间和进程地址空间上的共享区的一块地址空间形成映射关系。另外一进程在页表上，将同一块物理空间和该进程地址空间上的共享区的一块地址空间形成映射关系。

        当一个进程往该空间写入内容时，另外一进程访问该空间，会得到写入的值，即实现了进程间的通信。

         要实现进程间通信需要两个进程能够看到同一块空间，系统开辟的共享内存就是两进程看到的同一资源。

        注意：共享内存实现进程间通信是进程间通信最快的。

关于页表的补充：

        进程地址空间里有一个内核区域，它们也会在实际物理内存开辟空间，也会有页表与那块空间形成映射关系，这个页表叫做内核级页表。因为内核只有一个，所以每个进程都相同的。说明进程都共用实际物理内存上的内核空间。

        除内核空间以外的空间，与实际物理空间之间的页表，称为用户级页表。每个进程可能不同。

二.管理共享内存的数据结构

        共享内存实现进程间通信不只仅限于两个进程之间，可以用于多个进程之间。并且系统中可能会有多个进程在进行多个通信。所以系统需要将这些通信的进程管理起来。如果不管理，操作系统怎么知道这块共享内存挂接了哪个进程等信息。

        如何管理？先描述和组织。

        查看内核源代码，可以看到系统描述共享内存的数据结构如下：

/* Obsolete, used only for backwards compatibility and libc5 compiles */
struct shmid_ds {
	struct ipc_perm		shm_perm;	/* operation perms */
	int			shm_segsz;	/* size of segment (bytes) *///共享内存空间大小
	__kernel_time_t		shm_atime;	/* last attach time *///挂接时间
	__kernel_time_t		shm_dtime;	/* last detach time *///取消挂接时间
	__kernel_time_t		shm_ctime;	/* last change time *///改变时间
	__kernel_ipc_pid_t	shm_cpid;	/* pid of creator */
	__kernel_ipc_pid_t	shm_lpid;	/* pid of last operator */
	unsigned short		shm_nattch;	/* no. of current attaches *///进程挂接数
	unsigned short 		shm_unused;	/* compatibility */
	void 			*shm_unused2;	/* ditto - used by DIPC */
	void			*shm_unused3;	/* unused */
};

         描述共享内存的数据结构里保存了一个ipc_perm结构体，这个结构体保存了IPC(进程将通信)的关键信息。

/* Obsolete, used only for backwards compatibility and libc5 compiles */
struct ipc_perm
{
	__kernel_key_t	key;//共享内存的唯一标识符
	__kernel_uid_t	uid;
	__kernel_gid_t	gid;
	__kernel_uid_t	cuid;
	__kernel_gid_t	cgid;
	__kernel_mode_t	mode; //权限
	unsigned short	seq;
};

其中的key是共享内存的唯一标识。

三.共享内存函数

• ftok函数

       作用：算出一个唯一的key返回。

        参数：第一个是地址，第二个是至少8为的项目id，不能为0，两参数可以是任意值，但是要符合格式。

        返回值：ftok如果成功返回一个key值，如果失败返回-1。如果失败了再重新填写参数即可。 

        ftok中的参数可以随便填写，但是要符合格式，ftok只是利用参数，再运用一套算法，算出一个唯一的key值返回。这个key值可以传给共享内存参数，作为struct ipc_perm中唯一标识共享内存的key。

        ftok函数并没有涉及内核层面。

#pragma once

#define PATHNAME "./"
#define PROJ_ID 0x666

 #include<stdio.h>          
 #include<sys/types.h>     
 #include<sys/ipc.h>   
 #include"com.h"      
                       
 int main(){      
   key_t k = ftok(PATHNAME,PROJ_ID);    
   if(k==-1){              
     perror("ftok error");     
     return 1;    
   }             
   printf("ftok : %d\n",k);     
 
   return 0;       
} 

• shmget函数

作用：创建一个共享内存 

参数：

        key：为共享内存的名字，一般是ftok的返回值。

        size：共享内存的大小，以page为单位，大小为4096的整数倍。

        shmflg：权限标志，常用两个IPC_CREAT和IPC_EXCL，一般后面还加一个权限，相当于文件的权限。

                                IPC_CREAT：创建一个共享内存返回，已存在打开返回

                                IPC_EXCL：配合着IPC_CREAT使用，共享内存已存在出错返回。

                                使用：IPC_CREAT | IPC_EXCL | 0666

返回值：

        成功返回一个非负整数，即共享内存的标识码，失败返回-1。

        为什么已经有一个key来标识共享内存，还需要一个返回值来标识共享内存？因为key是内核级别的，供内核标识，shmget返回值是用户级别的，供用户使用的。

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include"com.h"

int main(){
	key_t k = ftok(PATHNAME, PROJ_ID);
	if (k == -1){
		perror("ftok error");
		return 1;

	}

	printf("ftok : %d\n", k);

	int shmid = shmget(k, SIZE, IPC_CREAT | IPC_EXCL | 0666);
	if (shmid == -1){
		perror("shmget error");
		return 1;

	}
	printf("shmid : %d\n", shmid);
	return 0;

}

        我们发现当进程创建了一个共享内存，没有释放，进程结束后，共享内存还在，所以第二次执行程序，会报错(报错是因为IPC_EXCL)。

        这里得出一个结论：IPC(进程将通信)资源生命周期不随进程，而是随内核的，不释放会一直占用，除非重启。所以，shmget创建的共享内存要释放掉，不然会内存泄漏。

        可以用命令行来释放共享内存：ipcrm -m shmid(shmget返回值)

         也可以用下面的函数来释放共享内存

• shmctl函数

作用：用于控制共享内存

参数：        shmid：共享内存的标识

                   cmd：以什么方式来控制共享内存。IPC_RMID是释放共享内存

                   buf：指向一个共享内存的数据结构 。struct shmid_ds

返回值：成功返回0，失败返回-1。

  1 #include<stdio.h>
  2 #include<sys/types.h>
  3 #include<sys/ipc.h>
  4 #include<sys/shm.h>
  5 #include"com.h"
  6 
  7 int main(){
  8   key_t k = ftok(PATHNAME,PROJ_ID);//获取一个唯一标识符key
  9   if(k==-1){
 10     perror("ftok error");
 11     return 1;
 12   }
 13 
 14   printf("ftok : %d\n",k);
 15 
 16   int shmid = shmget(k,SIZE,IPC_CREAT | IPC_EXCL | 0666);//创建共享内存
 17   if(shmid == -1){
 18     perror("shmget error");
 19     return 1;
 20   }
 21   printf("shmid : %d\n",shmid);
 22 
 23   int sh = shmctl(shmid,IPC_RMID,NULL);//删除共享内存
 24   if(sh == -1){                                                                                                                                          
 25     perror("shmctl");
 26     return 1;
 27   }
 28   return 0;
 29 }

 现在就可以执行多次：

•  shmat函数

作用：使创建的共享内存与调用该函数进程的进程地址空间参数关联。

参数：

        shmid：共享内存的标识，shmget的返回值。

        shmaddr：指定进程地址空间连接的地址。如果设置为null，默认让系统定要关联的地址。

        shmflg： 权限，常见有两个SHM_RDONLY(只读)和SHM_REMAP(重新映射一个进程地址空间没这样shmaddr不能为空)。设为0，系统默认。

 返回值：

        返回映射到进程地址空间共享区的开始地址。

• shmdt函数

 作用：删除共享内存与进程地址空间的映射关系，将页表映射关系删除，释放进程地址空间。

参数：

        shmaddr：共享内存映射到进程地址空间的地址。shmat返回值。

返回值：

        成功返回0，失败返回-1

shmat和shmdt要一起使用才起作用。

  1 #include<stdio.h>                                                        
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<sys/ipc.h>
  5 #include<sys/shm.h>
  6 #include"com.h"
  7 
  8 int main(){
  9   key_t k = ftok(PATHNAME,PROJ_ID);
 10   if(k==-1){
 11     perror("ftok error");
 12     return 1;
 13   }
 14 
 15   printf("ftok : %d\n",k);
 16   int shmid = shmget(k,SIZE,IPC_CREAT | IPC_EXCL | 0666);
 17   if(shmid == -1){
 18     perror("shmget error");
 19     return 1;
 20   }
 21   printf("shmid : %d\n",shmid); 
 22   //与进程地址空间产生关联
 23   char *str = (char *)shmat(shmid, NULL, 0);
 24   //10秒后删除关联
 25   sleep(10);
 26   shmdt(str);
 27 
 28   //int sh = shmctl(shmid,IPC_RMID,NULL);
 29   //if(sh == -1){      
 31   //  return 1;
 32   //}
 33   return 0;
 34 }               

 程序10秒钟删除共享内存与进程地址空间的关联：

四.实现进程间通信

        实现进程间通信步骤：

1. 创建共享内存
2. 共享内存关联进程
3. 删除共享内存与进程的关联
4. 释放共享内存

使用到上面的函数。

实现一个用户client与服务器server之间的简单通信。

需要client和server都和共享内存关联。client端不创建共享内存，不释放共享内存，server端创建共享内存，并且释放共享内存。

  1 #pragma once
  2 
  3 #define PATHNAME "./"
  4 #define PROJ_ID 0x666
  5 
  6 #define SIZE 4096 

client代码：写入端

 1 #include<stdio.h>                                                        
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<sys/ipc.h>
  5 #include<sys/shm.h>
  6 #include"com.h"
  7 
  8 int main(){
  9   key_t k = ftok(PATHNAME,PROJ_ID);
 10   if(k==-1){
 11     perror("ftok error");
 12     return 1;
 13   }
 14   //不创建共享内存，只是为了得到shmid
 15   int shmid = shmget(k, SIZE, 0);
 16   if(shmid == -1){
 17     perror("shmget error");
 18     return 1;
 19   }
 20   //与进程地址空间产生关联
 21   char *str = (char *)shmat(shmid, NULL, 0);
 22   char c='a';
 23   for(;c<='z';c++){
 24     str[c-'a']=c;
 25     sleep(5);
 26   }
 27   //删除关联
 28   shmdt(str);
 29   //不用释放共享内存，服务器端释放
 30 
 31   return 0;
 32 }   

server代码：读出端

 1 #include<stdio.h>                                                        
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<sys/ipc.h>
  5 #include<sys/shm.h>
  6 #include"com.h"
  7 
  8 int main(){
  9   key_t k = ftok(PATHNAME,PROJ_ID);
 10   if(k==-1){
 11     perror("ftok error");
 12     return 1;
 13   }
 14   //服务器关不要加IPC_EXCL，已存在不要保存，直接返回
 15   int shmid = shmget(k,SIZE,IPC_CREAT | IPC_EXCL | 0666);
 16   if(shmid == -1){
 17     perror("shmget error");
 18     return 1;
 19   }
 20   //与进程地址空间产生关联
 21   char *str = (char *)shmat(shmid, NULL, 0);
 22   //读数据
 23   while(1){
 24     printf("%s\n",str);
 25     sleep(1);
 26   }
 27   //删除关联
 28   shmdt(str);
 29   int sh = shmctl(shmid,IPC_RMID,NULL);
 30   if(sh == -1){
 31     perror("shmctl");
 32     return 1;
 33   }
 34   return 0;
 35 }         

代码输出，每隔5秒写端往共享内存中写一个字符，读端每个一秒读一下数据。

这里有一个问题：因为写端比读端慢，相比较于管道，当写端比读端慢时，没有写入时，读端要进入阻塞状态，但是上面发现使用共享内存的读端一直在读，并没有阻塞。

这里得出一个结论：共享内存实现的进程间通信底层不提供任何同步与互斥机制。如果想让两进程很好的合作起来，在IPC里要有信号量来支撑。

        注意：两进程之间用通过同样的规则即ftok参数要一样，来获取同样的key值，然后在创建共享内存时，用这个key值唯一标识共享内存，所以两进程时通过同样的key值来实现看到同一份资源。

补充：

共享内存

共享内存的理解

共享内存是System V版本的一个进程间通信方式。共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。

特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取，所以我们通常需要用其他的机制来同步对共享内存的访问，例如信号量。

共享内存通信原理

在之前学习管道时就说过多个进程之间要实现通信的话，就得让它们看到同一个资源，通过这个资源来实现通信。

在共享内存中是让他们看到同一块内存。在Linux中，每个进程都有属于自己的进程控制块（PCB）和地址空间（Addr Space），并且都有一个与之对应的页表，负责将进程的虚拟地址与物理地址进行映射，通过内存管理单元（MMU）进行管理。两个不同的虚拟地址通过页表映射到物理空间的同一区域，它们所指向的这块区域即共享内存

 

当两个进程通过页表将虚拟地址映射到物理地址时，在物理地址中有一块共同的内存区，即共享内存，这块内存可以被两个进程同时看到。这样当一个进程进行写操作，另一个进程读操作就可以实现进程间通信。但是，我们要确保一个进程在写的时候不能被读，因此我们使用信号量来实现同步与互斥 。

但是我们要怎么判断两个进程是挂载到了同一块内存空间，因为内存空间中可能不止一个共享内存，这里我们了解一个创建key值的函数ftok()函数，这里的key值就是这块共享内存空间的唯一标识符。两个进程通过同一个key值挂载到同一块共享内存。

key_t ftok(const char* pathname,int proj_id);

参数解释：

​ *pathname就是你指定的文档名

​ proj_id是子序号

返回值：成功返回一个key值，失败返回-1。

nattch是共享内存的挂载计数器，对于一个共享内存，实现采用的是引用计数的原理，当进程脱离共享存储区后，计数器减一，挂载成功时，计数器加一，只有当计数器变为零时，才能被删除。当进程终止时，它所附加的共享存储区都会自动脱离。

共享内存的接口函数以及指令

指令

1查看系统中的共享储存

ipcs -m

2手动删除系统中的共享内存

ipcrm -m [shmid]

接口函数

1、创建共享内存

int shmget(key_t key,size_t size, int shmflg)

参数解释：

​ key: ftok()函数生成的key值，标识系统中唯一的IPC资源。

​ size:我们要申请的共享内存大小，最好是页的整数倍，一页是4k字节。

​ shmflg:如果要创建新的共享内存，需要使用IPC_CREAT,IPC_EXCL,如果是已经存在的，可以使用IPC_CREAT或者直接传0。

返回值：

​ 成功时返回一个新建或已经存在的的共享内存标识符，取决于shmflg的参数。失败返回-1并设置错误码。

2、挂载共享内存

void* shmat(int shmid,const void *shmaddr,int shmflg);

参数解释：

​ shmid:共享内存的标识符。

​ shmaddy:shmaddr=0,则存储段连接到由内核选择的第一个可用地址上（推荐使用）。

​ shmflg:若指定了SHM_RDONLY位，则以只读方式链接共享内存，否则以读写方式链接。

返回值：

​ 成功返回共享存储段的指针（虚拟地址），并且内核将使其与该共享存储段相关的shmid_ds结构中的shm_nattch计数器加1（类似于引用计数）；出错返回-1 。

3、去关联共享内存

当进程之间完成通信时，就需要去关联，需要将该进程从之前连接的共享内存上脱离下来。

int shmdt(const void* shmaddr);

参数解释：

​ shmaddr:shmat()函数成功的返回值。

返回值

​ 成功返回0，并将shmid_ds结构体中的 shm_nattch计数器减1；出错返回-1

4、释放共享内存

当shm_nattch为0时就需要释放这块共享内存，否则就会一直占用下去，因为共享内存的生命周期是跟随内核的。

int shmctl(int shmid,int cmd,struct shmid_ds* buf);

参数解释：

​ shmid:共享内存标识符。

​ cmd:指定执行的操作，设置为IPC_RMID时表示释放共享内存。

​ buf:暂时不需要了解，设置为NULL就行。

返回值：

​ 成功返回0，失败返回-1.

模拟共享内存

//server.c
#include<stdio.h>    
#include<unistd.h>    
#include"comm.h"    
#include<sys/types.h>    
#include<sys/ipc.h>    
#include<sys/shm.h>    
int main()    
{    
  //ftok创建key值    
  key_t k=ftok(PATHNAME,PROJ_ID);    
    
  //根据key值创建共享内存    
  int shmid=shmget(k,SIZE,IPC_CREAT|IPC_EXCL|0666);    
  //判断是否创建成功    
  if(shmid<0)    
  {    
    perror("shmget");    
    return 1;    
  }    
  //挂载共享内存    
  char* str=(char*)shmat(shmid,NULL,0);    
  //int i=0;    
  while(1)    
  {    
    //i++;                                                                                                                                                   
    sleep(1);    
    printf("%s\n",str);    
  }    
  //去关联    
  shmdt(str);    
  //释放共享内存    
  shmctl(shmid,IPC_RMID,NULL);    
  return 0;    
}   

//client.c
#include<stdio.h> 
#include<unistd.h>    
#include"comm.h"     
#include<sys/types.h>                                                                          
#include<sys/ipc.h>                                                                            
#include<sys/shm.h>                                                                             
int main()                                                                                   
{                                                                                   
  //ftok创建key值                                                                                   
  key_t k=ftok(PATHNAME,PROJ_ID);                                                                                   
                                                                                   
  //根据key值找到共享内存                                                                                   
  int shmid=shmget(k,SIZE,0);                                                                                                         
  //判断是否创建成功                                                                                   
  if(shmid<0)                                                                                   
  {                                                                                   
    perror("shmget");                                                                                   
    return 1;                                                                                   
  }                                                                                   
  //挂载共享内存                                                                                   
  char* str=(char*)shmat(shmid,NULL,0);                                                                                   
  char c='a';                                                                                  
  for(;c<='z';c++)                                                                           
  {                                                                                   
    str[c-'a']=c;                                                             
    sleep(2);
  }
  //去关联
  shmdt(str);
  //这里不用释放共享内存，只需要释放一次就可以，server.c已经释放了。
  //shmctl(shmid,IPC_RMID,NULL);
  return 0;
}   

共享内存

---

---

一、共享内存

  共享内存 : 用于进程间的数据共享

1.共享内存实现通信的原理

开辟一块物理内存空间, 各个进程将同一块物理内存空间映射到自己的虚拟地址空间中, 通过虚拟地址进行访问, 进而实现数据共享
  共享内存是最快的进程间通信方式, 因为通过虚拟地址空间映射后, 直接通过虚拟地址访问物理内存, 相较于其他方式少了两步数据拷贝的操作.

2.操作流程

1.创建或打开共享内存

int shmget(key_t key, size_t size, int shmflg);

 key: 标识符- -通过相同的标识符, 多个进程就可以打开同一块共享内存;

 size: 要创建的共享内存大小;

 shmflg: 打开方式 + 权限;  IPC_CREAT: 不存在则创建, 存在则打开;
             IPC_EXCL与IPC_CREAT搭配使用, 文件存在则报错, 不存在则创建打开;

 返回值: 成功返回非负整数–操作句柄; 失败返回-1;

2.与进程建立映射关系

void *shmat(int shmid, const void *shmaddr, int shmflg);

 shmid: shmget返回的操作句柄;

 shmaddr: 映射的首地址, 通常置NULL;

 shflg: SHM_RDONLY-只读;  0-可读可写;

 返回值: 成功返回映射后的首地址;  失败返回(void*)-1;

3.对共享内存进行内存操作
 凡是涉及到内存操作的接口, 都能对共享内存进行操作;memcpy, strcpy, printf...... 4.与进程间解除映射关系

int shmdt(const void *shmaddr);

 shmaddr: shmat返回的映射首地址;
 返回值: 成功返回0; 失败返回-1;


5.删除共享内存

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

 shmid: shmget返回的操作句柄;
 cmd: 要对共享内存进行的操作类型;
   IPC_CMD: 标记要删除的共享内存段;
    映射连接数为0时删除共享内存; 禁止新的映射连接

 buf: 用于获取或设置共享内存属性的, 简单使用置NULL即可;
 返回值: 成功返回0; 失败返回-1;

二、代码实践

1.创建共享内存

代码如下（示例）：

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <sys/shm.h>
  5 #define IPC_KEY 0x01234567
  6 #define PROJ_ID 0x01234567
  7 int main()
  8 {
  9     //key_t key = ftok("./", PROJ_ID);
 10     //shmget(标识符, 大小, 打开方式和权限)
 11     int shmid = shmget(IPC_KEY, 32, IPC_CREAT | 0664);
 12     if(shmid < 0){
 13         perror("shmget error");
 14         return -1;
 15     }
 16     return 0;
 17 }

ipcs: 查看系统内核当中所有的进程间通信资源; ipcs -m: 查看共享内存; ipcs -q: 查看消息队列;ipcs -s: 查看信号量;

2.映射到虚拟地址

代码如下（示例）：

 16     //shmat(句柄, 映射首地址, 访问方式)
 17     void *shm_start = shmat(shmid, NULL, 0);
 18     if(shm_strat == (void*)-1){
 19         perror("shmat error");
 20         return -1;
 21     }
 22     while(1){
 23         printf("%s\n", (char*)shm_start);
 24         sleep(1);
 25     }
 26     shmdt(shm_start);
 27     //shmctl(句柄, 操作类型, 信息结构)
 28     shmctl(shmid, IPC_RMID, NULL);
 29     return 0;
 30 }

3.修改共享内存(一个写, 一个读)

关闭read, write仍然一直在修改, 关闭write, read也一直在读, 两边互不影响
两边同时打开, 映射连接数为2;

总结

共享内存:
 通信原理: 开辟一块物理内存, 多个进程将同一块内存映射到自己的虚拟地址空间, 进行访问, 进而实现数据共享.
 特性:
  1.效率最高的进程间通信方式;
  2.声明周期随内核;
注意事项: 各个进程对共享内存的操作都是不安全的操作