linux进程通信（一）--共享内存+信号量，代码示例

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

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

 

[cpp] view plaincopy

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 plaincopy

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 plaincopy

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. }