Linux---共享内存

1.ipcs命令

IPC机制是一个让人烦恼的问题：编写错误的程序或因为某些原因而执行失败的程序将把它的IPC资源（如消息队列中的数据）遗留在系统里，并且这些资源在程序结束后很长时间让然在系统中游荡，这导致对程序的新调用执行失败，因为程序期望以一个干净的系统来启动，但事实上却发现一些遗留的资源。

状态命令ipcs和删除命令（ipcrm)提供了一种检查和清理IPC机制的方法

ipcs -s只查看信号量

ipcs -m只查看共享

ipcs -q只查看消息队列

ipcrm删除操作

例如：ipcrm -s semid;

重启一下，信号量等自动删除

2.共享内存介绍

共享内存为多个进程之间共享和传递数据提供了一种有效的方式。共享内存是先在物理地址上申请一块空间，多个进程可以将其映射到自己的虚拟地址空间中。所以进程都可以访问共享内存中的地址 ，就好像它们是由malloc分配的一样。如果某个进程向共享内存写入了数据，所做的改动将立刻被可以访问同一段共享内存的任何其他进程看到。

但是由于它并未提供同步机制，所以我们通常需要用其他的机制来同步对共享内存的访问。

5.共享内存函数介绍

1)shmget

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


shmget()用于创建或者获取共享内存

shmget()成功返回共享内存的 ID， 失败返回-1

key： 不同的进程使用相同的 key 值可以获取到同一个共享内存,(这里的值和信号量的值一样也没有关系,因为类型不一样;)

size： 创建共享内存时，指定要申请的共享内存空间大小

shmflg: IPC_CREAT IPC_EXCL

2)shmat

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


shmat()将申请的共享内存的物理内存映射到当前进程的虚拟地址空间上

shmat()成功返回返回共享内存的首地址，失败返回 NULL(像malloc一样给共享空间的起始地址),看帮助手册失败返回的是-1;

shmaddr：一般给 NULL，由系统自动选择映射的虚拟地址空间

shmflg： 一般给 0(给0就代表的可读可写)， 可以给 SHM_RDONLY 为只读模式，其他的为读写

3)shmdt

int shmdt(const void *shmaddr);

shmdt()断开当前进程的 shmaddr 指向的共享内存映射

shmdt()成功返回 0， 失败返回-1

//为什么不是删除共享内存而是断开共享内存呢?因为你不使用了,

别的进程可能还在使用这块共享内存;

//删除共享内存用shmctl,就是对共享内存做控制,

那么可以设置,也可以删除,如下的函数;

4)shmctl

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

shmctl()控制共享内存

shmctl()成功返回 0，失败返回-1

cmd： IPC_RMID

//删除的时候如果还有人在使用共享内存,这个函数就会延迟删除,

等到最后一个进程断开链接它才会删除共享内存.

//第三个参数，buf是一个结构指针，它指向共享内存模式和访问权限的结构。

3.共享内存的使用

代码演示例1：

进程a向共享内存写入数据(写一次hello),进程b从共享内存读取数据(读取hello)并显示.

main.c写入数据

test.c读取数据

//main.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<assert.h>
#include<string.h>
int main()
{
	int shmid=shmget((key_t)1234,256,IPC_CREAT|0600);//创建一块动态内存
	assert(shmid!=-1);
	
	char *s=(char*)shmat(shmid,NULL,0);//一般给0,0表示
	//将申请的共享内存的物理地址映射到当前进程的虚拟空间上
	//assert(s!=NULL);
        if(s==(char*)-1)
	{
		exit(1);
	}
	strcpy(s,"hello");//把hello写到s里，即共享内存里写的就是hello
	shmdt(s);//断开当前进程的映射
}

//test.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<assert.h>
#include<string.h>
int main()
{
	int shmid=shmget((key_t)1234,256,IPC_CREAT|0600);//创建一块动态内存
	assert(shmid!=-1);
	
	char *s=(char*)shmat(shmid,NULL,0);//一般给0,0表示
	//将申请的共享内存的物理地址映射到当前进程的虚拟空间上
	//assert(s!=NULL);
        if(s==(char*)-1)
	{
		exit(1);
	}
	printf("%s",s);//打印获取的地址里面的内容
	shmdt(s);//断开当前进程的映射
        shmctl(shmid,IPC_RMID,NULL);//删除共享内存
	exit(0);
}

结果：

代码演示例2：

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

我们要了解进程管理的P V操作：

P:代表对资源的申请（-1）

V:代表对资源的释放（+1）

代码如下：

//main.c
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<assert.h>
#include<string.h>
int main()
{
	int shmid=shmget((key_t)1234,256,IPC_CREAT|0600);//创建一块动态内存
	assert(shmid!=-1);
	
	char *s=(char*)shmat(shmid,NULL,0);//一般给0,0表示
	//将申请的共享内存的物理地址映射到当前进程的虚拟空间上
	//assert(s!=NULL);
        if(s==(char*)-1)
	{
		exit(1);
	}
	//strcpy(s,"hello");//把hello写到s里，即共享内存里写的就是hello
	while(1)
	{
		printf("input:\n");
		char buff[128]={0};
		fgets(buff,128,stdin);

		strcpy(s,buff);//把buff里面的东西拷贝到s里面
                if(strncmp(buff,"end",3)==0)
		{
              		break;
		}//输入end表示退出
	}
	shmdt(s);//断开当前进程的映射
	exit(0);

}

//test.c
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<assert.h>
#include<string.h>
int main()
{
	int shmid=shmget((key_t)1234,256,IPC_CREAT|0600);//创建一块动态内存
	assert(shmid!=-1);
	
	char *s=(char*)shmat(shmid,NULL,0);//一般给0,0表示
	//将申请的共享内存的物理地址映射到当前进程的虚拟空间上
	//assert(s!=NULL);
        if(s==(char*)-1)
	{
		exit(1);
	}
	while(1)
	{
		if(strncmp(s,"end",3)==0)
		{
			break;
		}
	printf("read:%s\n",s);//打印获取的地址里面的内容
	sleep(1);
	}
	
	shmdt(s);//断开当前进程的映射
        shmctl(shmid,IPC_RMID,NULL);//删除共享内存
	exit(0);
}

这样会出问题， test.c如果没有sleep(1)就会疯狂的打印，所以共享内存必须结合信号量

正确做法：

遇到这类问题我们主要思考三个点：

1.信号量的个数

2.信号量的初始值

3.P V操作

//sem.h
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/sem.h>

#define SEM1 0
#define SEM2 1
#define SEM_MAX 2
union semun
{
	int val;
};
void sem_init();
void sem_p(int index);
void sem_v(int index);
void sem_destory();


//sem.c
#include"sem.h"

static int semid=-1;
void sem_init()
{
	semid=semget((key_t)1234,SEM_MAX,IPC_CREAT|IPC_EXCL|0600);//全新创建
	if(semid==-1)
	{
		semid=semget((key_t)1234,SEM_MAX,0600);//失败了就再获取一下
		if(semid==-1)
		{
			printf("sem failed!\n");//真的失败了
			return;
		}
	}
	else
	{
		union semun a;
		int arr[SEM_MAX]={1,0};
		for(int i=0;i<SEM_MAX;i++)
		{
			a.val=arr[i];
			if(semctl(semid,i,SETVAL,a)==-1)
			{
				printf("semctl setval failed!\n");
			}
		}
	}
}

void sem_p(int index)
{
	if(index<0||index>=SEM_MAX)
	{
		return;
	}
	struct sembuf a;
	a.sem_num=index;
	a.sem_op=-1;
	a.sem_flg=SEM_UNDO;

	if(semop(semid,&a,1)==-1)
	{
		printf("semop p error!\n");
	}
}


void sem_v(int index)
{
	if(index<0||index>=SEM_MAX)
	{
		return;
	}
	struct sembuf a;
	a.sem_num=index;
	a.sem_op=1;
	a.sem_flg=SEM_UNDO;

	if(semop(semid,&a,1)==-1)
	{
		printf("semop v error!\n");
	}
}

void sem_destory()
{
	if(semctl(semid,0,IPC_RMID)==-1)
	{
		printf("destory error!\n");
	}
}


//main.c
#include"sem.h"
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<assert.h>
#include<string.h>
int main()
{
	int shmid=shmget((key_t)1234,256,IPC_CREAT|0600);//创建一块动态内存
	assert(shmid!=-1);
	
	char *s=(char*)shmat(shmid,NULL,0);//一般给0,0表示
	//将申请的共享内存的物理地址映射到当前进程的虚拟空间上
	//assert(s!=NULL);
        if(s==(char*)-1)
	{
		exit(1);
	}
	//strcpy(s,"hello");//把hello写到s里，即共享内存里写的就是hello
	sem_init();
	while(1)
	{
		printf("input:\n");
		char buff[128]={0};
		fgets(buff,128,stdin);

		sem_p(SEM1);
		strcpy(s,buff);//把buff里面的东西拷贝到s里面
                sem_v(SEM2);
		if(strncmp(buff,"end",3)==0)
		{
              		break;
		}//输入end表示退出
	}
	shmdt(s);//断开当前进程的映射
	exit(0);

}



//test.c
include"sem.h"
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<assert.h>
#include<string.h>
int main()
{
	int shmid=shmget((key_t)1234,256,IPC_CREAT|0600);//创建一块动态内存
	assert(shmid!=-1);
	
	char *s=(char*)shmat(shmid,NULL,0);//一般给0,0表示
	//将申请的共享内存的物理地址映射到当前进程的虚拟空间上
	//assert(s!=NULL);
        if(s==(char*)-1)
	{
		exit(1);
	}
	sem_init();
	while(1)
	{
		sem_p(SEM2);
		if(strncmp(s,"end",3)==0)
		{
			break;
		}	
	printf("read:%s\n",s);//打印获取的地址里面的内容
	sem_v(SEM1);

	//sleep(1);
	}
       	
	shmdt(s);//断开当前进程的映射
    sem_destory();
	shmctl(shmid,IPC_RMID,NULL);//删除共享内存
	exit(0);
}

运行结果：