共享内存通信

1.基本概念
共享内存是IPC机制中的一种. 顾名思义,它允许两个不相关的进程访问同一段内存这是传递数据的一种非常有效的方式。


2.函数学习
第10类 共享内存编程

10.1 创建/获取共享内存

10.1.1 函数名

shmget

10.1.2 函数原形

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

10.1.3 函数功能

分配一个共享内存段，并返回其描述符

10.1.4 所属头文件

<sys/ipc.h> <sys/shm.h>

10.1.5 返回值

成功：返回创建或获取的共享内存描述符  失败：-1

10.1.6 参数说明

key：共享内存的键值

size：共享的内存大小

shmflg：打开标志，如果使用了IPC_CREAT则会新创建一块共享内存。

10.1.7 范例代码

10.2 映射共享内存

10.2.1 函数名

shmat

10.2.2 函数原形

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

10.2.3 函数功能

映射共享内存

10.2.4 所属头文件

<sys/types.h> <sys/shm.h>

10.2.5 返回值

成功：返回映射到进程空间之后的地址  失败：(void *）-1

10.2.6 参数说明

shmid:共享内存描述符

*shmaddr:接受的内存地址，如果为NULL自动选择映射地址

shmflg:共享内存标志位

10.3 分离共享内存

10.3.1 函数名

shmdt

10.3.2 函数原形

int shmdt(const void *shmaddr);

10.3.3 函数功能

断掉进程空间中与共享内存的联系

10.3.4 所属头文件

<sys/types.h> <sys/shm.h>

10.3.5 返回值

成功：返回0  失败：-1

10.2.6 参数说明

*shmaddr:需要分离的地址

10.4 控制共享内存

10.4.1 函数名

shmctl

10.4.2 函数原形

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

10.4.3 函数功能

控制共享内存

10.4.4 所属头文件

<sys/ipc.h> <sys/shm.h>

10.4.5 返回值

成功：根据不同的操作返回不同的值  失败：-1

10.4.6 参数说明

shmid：要控制的共享内存的id

cmd: 控制操作的命令，如：IPC_RMID(表示删除）

*buf:获取linux中描述共享内存的sdmid_ds结构,(0)

3.代码编写

write.c：

1. #include <sys/types.h>
   
2. #include <sys/ipc.h>
   
3. #include <sys/sem.h>
   
4. #include <stdio.h>
   
5. #include <unistd.h>
   
6. #include <stdlib.h>
   
7. 
   
8. #define TEXT_SZ 2048
   
9. 
   
10. struct shared_use_st
    
11. {
    
12.     int written_by_you;
    
13.     char some_text[TEXT_SZ];
    
14. };
    
15. 
    
16. int main()
    
17. {
    
18.     int running = 1;
    
19.     int shmid;
    
20.     struct shared_use_st *shared_stuff;
    
21.     char buffer[TEXT_SZ];
    
22.     /*创建共享内存*/
    
23.     shmid = shmget(1234 , sizeof(struct shared_use_st), IPC_CREAT);
    
24.     if(shmid == -1)
    
25.     {
    
26.         printf("creat share memory failed.\n");
    
27.         exit(EXIT_FAILURE);
    
28.     }
    
29. 
    
30.     /*映射共享内存*/
    
31.     shared_stuff = (struct shared_use_st *)shmat(shmid, NULL, 0);
    
32. 
    
33.     /*循环*/
    
34.     while(running)
    
35.     {
    
36.         while(shared_stuff->written_by_you == 1)
    
37.         {
    
38.             sleep(1);
    
39.             printf("wait read process!\n");
    
40.         }
    
41.     /*获取用户输入*/
    
42.         fgets(buffer, TEXT_SZ, stdin);
    
43.     /*把字符串放入共享内存*/
    
44.         strncpy(shared_stuff->some_text, buffer, TEXT_SZ);
    
45.         shared_stuff->written_by_you = 1;
    
46.        
    
47.         if(strncmp(buffer, "end", 3) == 0)
    
48.             running = 0;
    
49.     }
    
50.     /*脱离共享内存*/
    
51.     shmdt((const void *)shared_stuff);
    
52. 
    
53.     return 1;
    
54. }

read.c:

1. #include <sys/types.h>
   
2. #include <sys/ipc.h>
   
3. #include <sys/shm.h>
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. 
   
8. #define TEXT_SZ 4096
   
9. 
   
10. struct shared_use_st
    
11. {
    
12.     int written_by_you;
    
13.     char some_text[TEXT_SZ];
    
14. };
    
15. 
    
16. int main()
    
17. {
    
18.     int shmid;
    
19.     struct shared_use_st *share_stuff;
    
20.     int running = 1;
    
21.     /*创建共享内存*/
    
22.     shmid = shmget(1234, sizeof(struct shared_use_st), IPC_CREAT);
    
23.     if(shmid == -1)
    
24.     {
    
25.         printf("creat share memory failed.\n");
    
26.         exit(EXIT_FAILURE);
    
27.     }
    
28. 
    
29.     /*映射共享内存*/
    
30.     share_stuff = (struct share_use_st *)shmat(shmid, NULL, 0);
    
31. 
    
32.     /*循环*/
    
33.     while(running)
    
34.     {
    
35.     /*打印共享内存中的字符串*/
    
36.         if(share_stuff->written_by_you == 1)
    
37.         {
    
38.             printf("write process write %s \n", share_stuff->some_text);
    
39.             share_stuff->written_by_you = 0;
    
40.             
    
41.             if(strncmp(share_stuff->some_text, "end", 3) == 0)
    
42.                 running = 0;
    
43.         }
    
44.     }
    
45.     /*脱离共享内存*/
    
46.     shmdt((const void *)share_stuff);
    
47. 
    
48.     /*删除共享内存*/
    
49.     shmctl(shmid, IPC_RMID, 0);
    
50. 
    
51.     return 1;
    
52. }