IPC 信号和共享存储

以你之姓@ 2022-08-27 00:30 53阅读 0赞

理论很多，我们需要的是代码实践，呵呵！

来自：http://fengtong.javaeye.com/blog/456661

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\*server.c:向共享内存中写入People\*/
2.  \#include <stdio.h> 
3.  \#include <sys/types.h> 
4.  \#include <sys/ipc.h> 
5.  \#include <sys/sem.h> 
6.  
7.  **int** main() 
8.  \{ 
9.  **struct** People\{ 
10. **char** name\[10\]; 
11. **int** age; 
12.  \}; 
13. 
14. **int** semid; 
15. **int** shmid; 
16.  key\_t semkey; 
17.  key\_t shmkey; 
18.  semkey=ftok("server.c",0); 
19.  shmkey=ftok("client.c",0); 
20. 
21. /\*创建共享内存和信号量的IPC\*/
22.  semid=semget(semkey,1,0666|IPC\_CREAT); 
23. **if**(semid==-1) 
24.  printf("creat sem is fail/n"); 
25.  shmid=shmget(shmkey,1024,0666|IPC\_CREAT); 
26. **if**(shmid==-1) 
27.  printf("creat shm is fail/n"); 
28. 
29. /\*设置信号量的初始值，就是资源个数\*/
30. **union** semun\{ 
31. **int** val; 
32. **struct** semid\_ds \*buf; 
33.  ushort \*array; 
34.  \}sem\_u; 
35. 
36.  sem\_u.val=1; 
37.  semctl(semid,0,SETVAL,sem\_u); 
38. 
39. /\*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作\*/
40. 
41. **struct** People \* addr; 
42.  addr=(**struct** People\*)shmat(shmid,0,0); 
43. **if**(addr==(**struct** People\*)-1) 
44.  printf("shm shmat is fail/n"); 
45. 
46. /\*信号量的P操作\*/
47. **void** p() 
48.  \{ 
49. **struct** sembuf sem\_p; 
50.  sem\_p.sem\_num=0; 
51.  sem\_p.sem\_op=-1; 
52. **if**(semop(semid,&sem\_p,1)==-1) 
53.  printf("p operation is fail/n"); 
54.  \} 
55. 
56. /\*信号量的V操作\*/
57. **void** v() 
58.  \{ 
59. **struct** sembuf sem\_v; 
60.  sem\_v.sem\_num=0; 
61.  sem\_v.sem\_op=1; 
62. **if**(semop(semid,&sem\_v,1)==-1) 
63.  printf("v operation is fail/n"); 
64.  \} 
65. 
66. /\*向共享内存写入数据\*/
67.  p(); 
68.  strcpy((\*addr).name,"xiaoming"); 
69. /\*注意：①此处只能给指针指向的地址直接赋值，不能在定义一个 struct People people\_1;addr=&people\_1;因为addr在addr=(struct People\*)shmat(shmid,0,0);时,已经由系统自动分配了一个地址，这个地址与共享内存相关联，所以不能改变这个指针的指向，否则他将不指向共享内存，无法完成通信了。 
70. 注意：②给字符数组赋值的方法。刚才太虎了。。\*/
71.  (\*addr).age=10; 
72.  v(); 
73. 
74. /\*将共享内存与当前进程断开\*/
75. **if**(shmdt(addr)==-1) 
76.  printf("shmdt is fail/n"); 
77. 
78. \}

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\*client.c:从共享内存中读出People\*/
2.  \#include <stdio.h> 
3.  \#include <sys/types.h> 
4.  \#include <sys/ipc.h> 
5.  \#include <sys/sem.h> 
6.  
7.  **int** main() 
8.  \{ 
9.  **int** semid; 
10. **int** shmid; 
11.  key\_t semkey; 
12.  key\_t shmkey; 
13.  semkey=ftok("server.c",0); 
14.  shmkey=ftok("client.c",0); 
15. 
16. **struct** People\{ 
17. **char** name\[10\]; 
18. **int** age; 
19.  \}; 
20. 
21. /\*读取共享内存和信号量的IPC\*/
22.  semid=semget(semkey,0,0666); 
23. **if**(semid==-1) 
24.  printf("creat sem is fail/n"); 
25.  shmid=shmget(shmkey,0,0666); 
26. **if**(shmid==-1) 
27.  printf("creat shm is fail/n"); 
28. 
29. /\*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作\*/
30. **struct** People \* addr; 
31.  addr=(**struct** People\*)shmat(shmid,0,0); 
32. **if**(addr==(**struct** People\*)-1) 
33.  printf("shm shmat is fail/n"); 
34. 
35. /\*信号量的P操作\*/
36. **void** p() 
37.  \{ 
38. **struct** sembuf sem\_p; 
39.  sem\_p.sem\_num=0; 
40.  sem\_p.sem\_op=-1; 
41. **if**(semop(semid,&sem\_p,1)==-1) 
42.  printf("p operation is fail/n"); 
43.  \} 
44. 
45. /\*信号量的V操作\*/
46. **void** v() 
47.  \{ 
48. **struct** sembuf sem\_v; 
49.  sem\_v.sem\_num=0; 
50.  sem\_v.sem\_op=1; 
51. **if**(semop(semid,&sem\_v,1)==-1) 
52.  printf("v operation is fail/n"); 
53.  \} 
54. 
55. /\*从共享内存读出数据\*/
56.  p(); 
57.  printf("name:%s/n",addr->name); 
58.  printf("age:%d/n",addr->age); 
59.  v(); 
60. 
61. /\*将共享内存与当前进程断开\*/
62. **if**(shmdt(addr)==-1) 
63.  printf("shmdt is fail/n"); 
64. 
65. /\*IPC必须显示删除。否则会一直留存在系统中\*/
66. **if**(semctl(semid,0,IPC\_RMID,0)==-1) 
67.  printf("semctl delete error/n"); 
68. **if**(shmctl(shmid,IPC\_RMID,NULL)==-1) 
69.  printf("shmctl delete error/n"); 
70. \}

这里是比较通俗的解析：

2.3.3 共享内存  
　　 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。  
　　 首先要用的函数是shmget，它获得一个共享存储标识符。  
　　　　 \#include <sys/types.h>  
　　　　 \#include <sys/ipc.h>  
　　　　 \#include <sys/shm.h>  
　　　　 int shmget(key\_t key, int size, int flag);  
　　 这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key\_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。  
　　 当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。  
　　 void \*shmat(int shmid, void \*addr, int flag);  
　　 shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。  
　　 使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM\_LOCK、SHM\_UNLOCK等来实现。

2.3.4 信号量  
　　 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：  
　　 （1） 测试控制该资源的信号量。  
　　 （2） 若此信号量的值为正，则允许进行使用该资源。进程将进号量减1。  
　　 （3） 若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）。  
　　 （4） 当进程不再使用一个信号量控制的资源时，信号量值加1。如果此时有进程正在睡眠等待此信号量，则唤醒此进程。  
　　 维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文件/usr/src/linux/include　/linux　/sem.h中看到内核用来维护信号量状态的各个结构的定义。信号量是一个数据集合，用户可以单独使用这一集合的每个元素。要调用的第一个函数是semget，用以获得一个信号量ID。  
　　 \#include <sys/types.h>  
　　 \#include <sys/ipc.h>  
　　 \#include <sys/sem.h>  
　　 int semget(key\_t key, int nsems, int flag);  
　　 key是前面讲过的IPC结构的关键字，它将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。  
　　 semctl函数用来对信号量进行操作。  
　　 int semctl(int semid, int semnum, int cmd, union semun arg);  
　　 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。  
　　 semop函数自动执行信号量集合上的操作数组。  
　　 int semop(int semid, struct sembuf semoparray\[\], size\_t nops);  
　　 semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。  
　　 下面，我们看一个具体的例子，它创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后我们清除信号量。在下面的代码中，函数ftok生成我们上文所说的唯一的IPC关键字。

**\[cpp\]** [view plain][] [copy][view plain]

1.  \#include <stdio.h> 
2.  \#include <sys/types.h> 
3.  \#include <sys/sem.h> 
4.  \#include <sys/ipc.h> 
5.  **void** main() \{ 
6.  key\_t unique\_key; /\* 定义一个IPC关键字\*/
7.  **int** id; 
8.  **struct** sembuf lock\_it; 
9.  **union** semun options; 
10. **int** i; 
11. 
12. unique\_key = ftok(".", 'a'); /\* 生成关键字，字符'a'是一个随机种子\*/
13. /\* 创建一个新的信号量集合\*/
14. id = semget(unique\_key, 1, IPC\_CREAT | IPC\_EXCL | 0666); 
15. printf("semaphore id=%d/n", id); 
16. options.val = 1; /\*设置变量值\*/
17. semctl(id, 0, SETVAL, options); /\*设置索引0的信号量\*/
18. 
19. /\*打印出信号量的值\*/
20. i = semctl(id, 0, GETVAL, 0); 
21. printf("value of semaphore at index 0 is %d/n", i); 
22. 
23. /\*下面重新设置信号量\*/
24. lock\_it.sem\_num = 0; /\*设置哪个信号量\*/
25. lock\_it.sem\_op = -1; /\*定义操作\*/
26. lock\_it.sem\_flg = IPC\_NOWAIT; /\*操作方式\*/
27. **if** (semop(id, &lock\_it, 1) == -1) \{ 
28. printf("can not lock semaphore./n"); 
29. exit(1); 
30. \} 
31. 
32. i = semctl(id, 0, GETVAL, 0); 
33. printf("value of semaphore at index 0 is %d/n", i); 
34. 
35. /\*清除信号量\*/
36. semctl(id, 0, IPC\_RMID, 0); 
37. \}

[view plain]: http://blog.csdn.net/lanmanck/article/details/6100019#