150-Linux的共享内存(与信号量结合)

迷南。 2023-01-11 01:22 91阅读 0赞

## 共享内存 ##

共享内存为多个进程之间共享和传递数据提供了一种有效的方式。共享内存是先在物理内存上申请一块空间，**多个进程可以将其映射到自己的虚拟地址空间中**。**所有进程都可以访问共享内存中的地址**，就好像它们是由 malloc 分配的一样。如果某个进程向共享内存写入了数据，所做的改动将立刻被可以访问同一段共享内存的任何其他进程看到。**由于它并未提供同步机制，所以我们通常需要用其他的机制来同步对共享内存的访问。**  
**管道是把数据写在第三方空间  
而共享内存是共用一块内存空间，直接用就可以，不用拷贝**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]

**使用方法：**

#include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/types.h>
    
    /*
    shmget()用于创建或者获取共享内存
    shmget()成功返回共享内存的 ID，失败返回-1
    key：不同的进程使用相同的 key 值可以获取到同一个共享内存
    size：创建共享内存时，指定要申请的共享内存空间大小
    shmflg: IPC_CREAT IPC_EXCL
    */
    int shmget(key_t key, size_t size, int shmflg);
    
    
    /*
    shmat()将申请的共享内存的物理内存映射到当前进程的虚拟地址空间上,就是把箭头指向共享内存空间
    shmat()成功返回返回共享内存的首地址，失败返回 NULL
    shmaddr：一般给 NULL，由系统自动选择映射的虚拟地址空间
    shmflg： 一般给 0， 可以给 SHM_RDONLY 为只读模式，其他的为读写
    */
    void* shmat(int shmid, const void *shmaddr, int shmflg);
    //shmid: shmget()成功返回共享内存的 ID
    
    /*
    shmdt()断开当前进程的 shmaddr 指向的共享内存映射，就是把箭头切断，不是删除共享内存空间
    shmdt()成功返回 0， 失败返回-1
    */
    int shmdt(const void *shmaddr);
    
    
    /*
    shmctl()控制共享内存
    shmctl()成功返回 0，失败返回-1
    cmd： IPC_RMID
    可以设置或者删除，没人使用这块共享内存，系统才会删
    */
    int shmctl(int shmid, int cmd, struct shmid_ds *buf);

**可以使用命令查看**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][20210125173252104.png_pic_center]  
**创建共享内存**  
**vi a.c**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
**运行a程序前先查看现在有几个共享内存**  
![在这里插入图片描述][20210125173928240.png_pic_center]  
**运行a程序后查看**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
**此时已经创建了一个共享内存。没有人使用它。（进程结束）**  
**接下来实现映射**  
**vi a.c**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
**运行a程序中**  
![在这里插入图片描述][20210125174353809.png_pic_center]  
**可以看到有一个进程在使用这个共享内存（就是a程序）**  
**a进程结束后自动断开，我们查看**  
![在这里插入图片描述][20210125174506231.png_pic_center]  
**数字变为0**  
**进程一结束，自动断开**

**如果要人工断开，看下面这段代码**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
**在执行睡眠20秒之前，a进程就会与共享内存断开了**  
![在这里插入图片描述][20210125174807360.png_pic_center]  
**vi b.c(执行读取）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]  
**运行b程序**  
![在这里插入图片描述][20210125175158243.png_pic_center]  
**和管道有区别：如果是管道读取的话，读过去数据就消失了  
而从共享内存读数据，数据是不会消失的**  
**s指针指向共享内存的起始地址，每次都是从起始位置读取**

**共享内存空间大小是由自己定的，也可以是结构体类型大小**  
**每次映射都是指针指向共享内存空间的起始位置地址**

实现：  
**进程 a 向共享内存中写入数据，进程 b 从共享内存中读取数据并显示**  
**vi a.c**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]  
**vi b.c**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
**打开两个终端，分别运行a程序和b程序**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
如何实现：

## 进程 a 从键盘循环获取数据并拷贝到共享内存中，进程 b 从共享内存中获 取并打印数据。要求进程 a 输入一次，进程 b 输出一次，进程 a 不输入，进程 b 也不输出。 ##

引入信号量进行同步！

定义2个信号量s1,s2  
s1=1,s2=0;  
在a进程做：P(s1),V(s2)  
在b进程做：P(s2),V(s1）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]  
不管a还是b先执行起来都没有影响  
如果b先执行，s2=0,b执行P(s2)，就阻塞住了  
如果a先执行，s1=1,a执行P(s1)，可以通过，（这里的s1由1变为0），运行下去，往里写数据，要进入下一轮的写入的时候，进行了V(s2)操作，s2的值从0，变成1，b程序P(s2)可以通过了，(s2的值由1变为0),执行打印，b程序正在打印的过程中a程序不能写入（因为此时s1=0），只有b程序printf打印结束后，执行V(s1)，s1的值由0变为1,a程序执行P(s1)通过了，a运行下去，此时b程序被阻塞住了（因为s2=0）

**vi sem.h**

#ifndef __SEM_H
    #define __SEM_H
    
    #define SEM_W 0
    #define SEM_R 1
    
    typedef union SemUn
    {
        
    	int val;
    }SemUn;
    
    int SemGet(int key, int semVal[], int nsems);
    
    int SemP(int semid, int index);
    
    int SemV(int semid, int index);
    
    int SemDel(int semid);

**vi sem.c**

#include "sem.h"
    
    #include <sys/sem.h>
    #include <malloc.h>
    #include <string.h>
    #include <assert.h>
    
    
    int SemGet(int key, int semVal[], int nsems)
    {
        
    	int semid = semget((key_t)key, nsems, 0664);
    	if(semid == -1)
    	{
        
    		semid = semget((key_t)key, nsems, 0664|IPC_CREAT);
    		if(semid == -1)
    		{
        
    			return -1;
    		}
    
    		int i = 0;
    		for(; i < nsems; ++i)
    		{
        
    			SemUn un;
    			un.val = semVal[i];
    
    			if(-1 == semctl(semid, i, SETVAL, un))
    			{
        
    				perror("semctl error");
    				return -1;
    			}
    		}
    	}
    
    	return semid;
    }
    
    int SemP(int semid, int index)
    {
        
    	struct sembuf buf;
    	buf.sem_num = index;
    	buf.sem_op = -1;
    	buf.sem_flg = SEM_UNDO;
    	if(-1 == semop(semid, &buf, 1))
    	{
        
    		return -1;
    	}
    
    	return 0;
    }
    
    int SemV(int semid, int index)
    {
        
    	struct sembuf buf;
    	buf.sem_num = index;
    	buf.sem_op = 1;
    	buf.sem_flg = SEM_UNDO;
    
    	if(-1 == semop(semid, &buf, 1))
    	{
        
    		perror("semop error");
    		return -1;
    	}
    
    	return 0;
    }
    
    int SemDel(int semid)
    {
        
    	if(-1 == semctl(semid, 0, IPC_RMID))
    	{
        
    		perror("semctl del error");
    		return -1;
    	}
    
    	return 0;
    }

**vi shmA.c**

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<string.h>
    #include<assert.h>
    
    #include <sys/shm.h>
    #include "sem.h"
    
    int main()
    {
        
    	int shmid = shmget((key_t) 1234, 128, IPC_CREAT | 0664);
    	assert(shmid != -1);
    	int semVal[2] ={
        1, 0};
    	int semid = SemGet(1000, semVal, 2);
    
    	char *ptr = (char*)shmat(shmid, NULL, 0);
    	assert(ptr != (char*)-1);
    
    	while(1)
    	{
        
    		char buff[128] = {
        0};
    		printf("please input: ");
    		fgets(buff, 128, stdin);
    		SemP(semid, SEM_W);
    		strcpy(ptr, buff);
    
    		SemV(semid, SEM_R);
    
    		if(strncmp(ptr, "end", 3) == 0)
    		{
        
    			break;
    		}
    	}
    
    	shmdt(ptr);
    	shmctl(shmid, IPC_RMID, NULL);
    	exit(0);
    }

**vi shmB.c**

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<string.h>
    #include<assert.h>
    
    #include <sys/shm.h>
    #include "sem.h"
    
    int main()
    {
        
    	int shmid = shmget((key_t) 1234, 128, IPC_CREAT | 0664);
    	assert(-1 != shmid);
    
    	int semVal[2] = {
        1, 0};
    	int semid = SemGet(1000, semVal, 2);
    
    	char *ptr = (char *)shmat(shmid, NULL, 0);
    	assert((char*)-1 != ptr);
    
    	while(1)
    	{
        
    		SemP(semid, SEM_R);
    
    		if(strncmp(ptr, "end", 3) == 0)
    		{
        
    			break;
    		}
    
    		printf("lenth = %d : %s", strlen(ptr) - 1, ptr);
    		SemV(semid, SEM_W);
    	}
    
    	shmdt(ptr);
    	shmctl(shmid, IPC_RMID, NULL);
    	SemDel(semid);
    	exit(0);
    }

**编译过程**  
![在这里插入图片描述][20210125193239775.png_pic_center]  
**运行结果截图**  
![在这里插入图片描述][20210125193317825.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221119/5e3b28ed5eb44c7f961f48817d27ade3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221119/22df8fb3113e406487dd1d14f0c47a22.png
[20210125173252104.png_pic_center]: /images/20221119/7e44da89d8d84ad3b6fd564eeb24fd46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221119/d6f9be8143774f86a892b1d18a59861d.png
[20210125173928240.png_pic_center]: /images/20221119/d07f356accc547aa97ce9bdbd6d0fd48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221119/e024e5ae4dad40c2aae984dde2879eff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221119/2612675923f34cd9b29d5a8b46d8c341.png
[20210125174353809.png_pic_center]: /images/20221119/92f61d1c59da4a68846af0656f04bc11.png
[20210125174506231.png_pic_center]: /images/20221119/f8b5f9df7c3d447c9ab3ae8ed2b4be25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221119/a162aeb31e454e32b9984e213488c4c4.png
[20210125174807360.png_pic_center]: /images/20221119/ee3604ae358241ab9be2f4ec97adb707.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221119/ada2a6bb34bd4dff958908d1805e4c85.png
[20210125175158243.png_pic_center]: /images/20221119/1f11a2de3db54863b9532674026c7d97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221119/b291222cea794ca8bf63df01c4c2996d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/2021012517585731.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20210125180242478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20210125180249413.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20210125181134582.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20210125193239775.png_pic_center]: https://img-blog.csdnimg.cn/20210125193239775.png#pic_center
[20210125193317825.png_pic_center]: https://img-blog.csdnimg.cn/20210125193317825.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]: https://img-blog.csdnimg.cn/20210125194854121.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20210125194901970.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]: https://img-blog.csdnimg.cn/20210125194907503.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center