共享内存

一、共享内存的定义

共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一样。而如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。

 

二、共享内存的函数

与信号量一样，在Linux中也提供了一组函数接口用于使用共享内存，而且使用共享共存的接口还与信号量的非常相似，而且比使用信号量的接口来得简单，它们声明在头文件sys/shm.h中。

 

1、shmget函数（创建共享内存）

原型：

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

 

（1）key（非 0整数），它有效地为共享内存段命名，shmget函数成功时返回一个与key相关的共享内存标识符（非负整数），用于后续的共享内存函数。调用失败返回-1.

（2）size以字节为单位指定需要共享的内存容量。

（3）shmflg是权限标志，它的作用与open函数的mode参数一样，如果要想在key标识的共享内存不存在时，创建它的话，可以与IPC_CREAT做或操作。共享内存的权限标志与文件的读写权限一样，举例来说，0644,它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据，同时其他用户创建的进程只能读取共享内存。

 

2、shmat函数（把共享内存映射到一个地址）

第一次创建完共享内存时，它还不能被任何进程访问，shmat函数的作用就是用来启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间。它的原型如下：

void *shmat(int shm_id, const void *shm_addr, int shmflg);  

（1）shm_id是由shmget函数返回的共享内存标识。

（2）shm_addr指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址。

（3）shm_flg是一组标志位，通常为0。

调用成功时返回一个指向共享内存第一个字节的指针，如果调用失败返回-1.

 

3、shmdt函数（将共享内存从当前进程中分离）

注意，将共享内存分离并不是删除它，只是使该共享内存对当前进程不再可用。

原型：

int shmdt(const void *shmaddr); 

参数shmaddr是shmat函数返回的地址指针，调用成功时返回0，失败时返回-1.

 

4、shmctl函数（用来控制共享内存）

原型：

int shmctl(int shm_id, int command, struct shmid_ds *buf);  

 

（1）shm_id是shmget函数返回的共享内存标识符。

（2）command是要采取的操作，它可以取下面的三个值 ：

   IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值，即用共享内存的当前关联值覆盖shmid_ds的值。

   IPC_SET：如果进程有足够的权限，就把共享内存的当前关联值设置为shmid_ds结构中给出的值

   IPC_RMID：删除共享内存段

（3）buf是一个结构指针，它指向共享内存模式和访问权限的结构。

shmid_ds结构至少包括以下成员：

struct shmid_ds  

{  

    uid_t shm_perm.uid;  

    uid_t shm_perm.gid;  

    mode_t shm_perm.mode;  

};  

eg:

sem.h

1.	#include <stdio.h>  
2.	#include <stdlib.h>  
3.	#include <unistd.h>  
4.	#include <sys/sem.h>  
5.	  
6.	union semun  
7.	{  
8.	    int val;  
9.	};  
10.	  
11.	void sem_init(int,int);//因为要用到两个信号量，所以初始化时直接初始两个  
12.	void sem_p(int);  
13.	void sem_v(int);  
14.	void sem_destroy();  

sem.c

1.	#include "sem.h"  
2.	  
3.	static int semid = 0;  
4.	  
5.	void init(int in1,int in2)  
6.	{  
7.	    if((semid  =  semget((key_t)1234,2,IPC_CREAT|IPC_EXCL|0600)) == -1)  
8.	    {  
9.	        if((semid = semget((key_t)1234,2,IPC_EXCL)) == -1)  
10.	        {  
11.	            perror("semget error;\n");  
12.	        }  
13.	    }  
14.	    else  
15.	    {  
16.	        union semun buf;  
17.	        buf.val = in1;  
18.	        if(semctl(semid,0,SETVAL,buf) == -1)  
19.	        {  
20.	            perror("semctl error");  
21.	        }  
22.	  
23.	        union semun buf1;  
24.	        buf1.val = in2;  
25.	        if(semctl(semid,1,SETVAL,buf1) == -1)  
26.	        {  
27.	            perror("semctl error");  
28.	        }  
29.	    }  
30.	}  
31.	void sem_p(int num)  
32.	{  
33.	    struct sembuf buff;  
34.	    buff.sem_num = num;  
35.	    buff.sem_op = -1;  
36.	    buff.sem_flg = SEM_UNDO;  
37.	    if(semop(semid,&buff,1) == -1)  
38.	    {  
39.	        perror("semop error");  
40.	    }  
41.	}  
42.	void sem_v(int num)  
43.	{  
44.	  
45.	    struct sembuf buff;  
46.	    buff.sem_num = num;  
47.	    buff.sem_op = 1;  
48.	    buff.sem_flg = SEM_UNDO;  
49.	    if(semop(semid,&buff,1) == -1)  
50.	    {  
51.	        perror("semop error");  
52.	    }  
53.	}  
54.	  
55.	void destroy()  
56.	{  
57.	    if(semctl(semid,0,IPC_RMID) == -1)  
58.	    {  
59.	        perror("destory error");  
60.	    }  
61.	  
62.	}  

write.c

1.	#include <stdio.h>  
2.	#include <stdlib.h>  
3.	#include <string.h>  
4.	#include <unistd.h>  
5.	#include <assert.h>  
6.	#include <fcntl.h>  
7.	#include <sys/sem.h>  
8.	#include <sys/shm.h>  
9.	#include "sem.h"  
10.	  
11.	int main()  
12.	{  
13.	    int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);  
14.	    if(shmid == -1)  
15.	    {  
16.	        perror("shmget error:");  
17.	    }  
18.	    void * id = (void *)0;  
19.	    id = shmat(shmid,NULL,0);  
20.	    if(id  == (void  *)-1)  
21.	    {  
22.	        perror("shmat error:");  
23.	    }  
24.	  
25.	    char * s = (char * )id;  
26.	  
27.	    init(1,0);  
28.	    int i = 0;  
29.	    while(1)  
30.	    {  
31.	        sem_p(0);  
32.	        fgets(s,128,stdin);  
33.	  
34.	        sem_v(1);  
35.	        if(strncmp(s,"end",3) == 0)  
36.	        {  
37.	            break;  
38.	        }  
39.	    }  
40.	  
41.	    if(shmdt(s) == -1)  
42.	    {  
43.	        perror("shmdt error:");  
44.	    }  
45.	    sleep(10);  
46.	    shmctl(shmid,IPC_RMID,0);  
47.	    destroy();  
48.	}  

read.c

1.	#include <stdio.h>  
2.	#include <stdlib.h>  
3.	#include <string.h>  
4.	#include <unistd.h>  
5.	#include <assert.h>  
6.	#include <sys/sem.h>  
7.	#include <sys/shm.h>  
8.	#include "sem.h"  
9.	  
10.	int main()  
11.	{  
12.	    int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);  
13.	    if(shmid == -1)  
14.	    {  
15.	        perror("shmget error:");  
16.	    }  
17.	    char *s = (char *)shmat(shmid,NULL,0);  
18.	    if(s == (char *)-1)  
19.	    {  
20.	        perror("shmat error:");  
21.	    }  
22.	    init(1,0);  
23.	       //init(0);  
24.	        int i = 0;  
25.	    while(1)  
26.	    {  
27.	        sem_p(1);  
28.	        if(strncmp(s,"end",3) == 0)  
29.	        {  
30.	            break;  
31.	        }  
32.	        printf("%s",s);  
33.	          
34.	        sem_v(0);  
35.	    }  
36.	    if(shmdt(s) == -1)  
37.	    {  
38.	        perror("shmdt error:");  
39.	    }  
40.	}