linux下C的共享内存编程

unix/linux 环境下，IPC的方式有3种： 消息队列、信号、共享内存

#include <sys/types.h>
#include <sys/ipc.h>

共享内存使用方法（shared memory），主要使用以下这几个函数：

1) ftok   <file to key>根据一个文件路径（相应的文件必须存在）和一个数值(char类型），计算出一个key，这个key用于提供给其他IPC函数。

2) shmget  <shared memory get> 用于创建/获取已有的共享内存

3) shmat <shared memory attach>  将共享内存映射到本身的一个内存地址

4) shmdt  <shared memory detach>  取消映射已映射到内存地址的共享内存

5) shmctl <shared memory control>  用于读取、设置共享内存的状态或者删除共享内存。

（其实共享内存还有其他的函数，例如 shm_开头的函数）

典型用法：

ftok   ---<key_t>---->>  shmget  -----<shmid>---->>  shmat  -------(void*, use it)----->> shmdt------>>shmctl<IPC_RMID>

1、先用 ftok 算出一个key_t（或者不调用ftok，手动指定一个固定的key_t，一个整数）

2、然后将上面得到的key_t传给 shmget，shmget 会检查这个key上面是否有已经存在的共享内存，如果有合适的会直接返回一个，如果没有，则会创建一个

3、shmget返回一个共享内存的id（int类型），然后调用shmat，将这个共享内存映射到本地进程的一个地址（可以自己指定，也可以传NULL，由系统指定）

4、shmget返回的内存地址就是映射之后的共享内存，可以像访问自身内存一样使用这块内存。

5、使用完成之后，将这个内存地址传给 shmdt，脱离映射。

6、如果这个共享内存是你创建的，你还需要在合适的时候调用 shmctl，给这个共享内存做个删除标记。这样当所有进程都与这个共享内存分离之后，这个共享内存才会真正被删除。

提示：

经常需要配合使用进程同步的系统函数

static void mysleep(int seconds) {  

1.     for ( ; seconds > 0; seconds-- ) {  
2.         sleep(1); printf("sleeping(%d)\n", seconds);  
3.     }  
4. }  
5.   
6. int main() {  
7.     key_t key = ftok("./mark", (int)'a');  
8.     int shmid = shmget(key, 100, IPC_CREAT | 0600);  
9.     void* buf = (void*)shmat(shmid, NULL, 0);  
10.         if ( (int)buf == -1 ) {  
11.         shmctl(shmid, IPC_RMID, NULL);  
12.         exit(1);  
13.     }  
14.   
15.     sprintf(buf, "hello, world\n");  
16.     mysleep(5);  
17.     sprintf(buf,"niu bi....niu bi....\n");  
18.     mysleep(5);  
19.   
20.     if ( -1 == shmdt(buf) ) {  
21.         fprintf(stderr, "%s\n", strerror(errno));  
22.         shmctl(shmid, IPC_RMID, NULL);  
23.         exit(1);  
24.     }  
25.   
26.     if ( -1 == shmctl(shmid, IPC_RMID, NULL) ) {  
27.         fprintf(stderr, "%s\n", strerror(errno));  
28.         exit(1);  
29.     }  
30.   
31.     printf("producer exited normally\n");  
32.     return 0;  
33. }  

static void mysleep(int seconds) {
	for ( ; seconds > 0; seconds-- ) {
		sleep(1); printf("sleeping(%d)\n", seconds);
	}
}

int main() {
	key_t key = ftok("./mark", (int)'a');
	int shmid = shmget(key, 100, IPC_CREAT | 0600);
	void* buf = (void*)shmat(shmid, NULL, 0);
        if ( (int)buf == -1 ) {
		shmctl(shmid, IPC_RMID, NULL);
		exit(1);
	}

	sprintf(buf, "hello, world\n");
	mysleep(5);
	sprintf(buf,"niu bi....niu bi....\n");
	mysleep(5);

	if ( -1 == shmdt(buf) ) {
		fprintf(stderr, "%s\n", strerror(errno));
		shmctl(shmid, IPC_RMID, NULL);
		exit(1);
	}

	if ( -1 == shmctl(shmid, IPC_RMID, NULL) ) {
		fprintf(stderr, "%s\n", strerror(errno));
		exit(1);
	}

	printf("producer exited normally\n");
	return 0;
}

int main(int argc, char* argv[])  

1. {  
2.     key_t key = ftok("./mark", 'a');  // 要保证两个进程的key_t，才能正确使用共享内存   
3.     int shmid = shmget(key, 100, 0600);  
4.     void* buf = (void*)shmat(shmid, NULL, 0);  
5.   
6.     printf("shared memory: %s\n", buf);  
7.     sleep(8);  
8.     printf("shared memory: %s\n", buf);  
9.   
10.     if ( -1 == shmdt(buf) ) {  
11.         fprintf(stderr, "%s\n", strerror(errno));  
12.         exit(1);  
13.     }  
14.   
15.     printf("consumer exited normally\n");  
16.     return 0;  
17. }