Linux 进程通信(System V) 第五节 ------>共享内存区

梦里梦外; 2022-06-13 03:12 142阅读 0赞

**一：简介**  
  
前面已经学过：pipe，FIFO，msg queue， 今天要学的是“共享内存区”  
  
1.共享内存区是进程通信中最快的方式，而且传递的信息量是很大的！  
2.是通过内存区间映射到进程空间来实现的！因此这种进程间的通信不再涉及到内核！  
(即进程不是通过执行任何的进入内核的系统调用来传递数据的。这样内核就必须建立允许各个进程之间的共享内存区的映射关系，然后一直管理该内存区！同时也要保证所谓的同步，有序，而且没有死锁！)  
3.简单的实现过程：

<1>.server获得访问共享内存区的权限  
                              <2>.server从输入文件中读取数据到共享内存区(需要一次copy内容 )  
                              <3>.server输入数据OK后，通知用户进程  
                              <4>.最后用户进程从共享内存区中取出data( 需要一次copy内容)  
                               
                              但是与pipe，FIFO以及msg queue的区别是：  
                                                              此三者需要进程的操作是：server和client的发送和接受data都是需要进行一次copy，所以一共有4次数据拷贝，所以效率不如“共享内存区”  
                               
4.数据结构：  
                               \#include<sys/shm.h>  
                               
                               structshmid\_ds  
                               \{  
                                     structipc\_perm            shm\_perm;                  //!> 权限设置结构体  
                                     size\_t                              shm\_segsz;                  //!> 内存块大小  
                                    pid\_t                              shm\_lpid;                        //!> 最后一次操作的进程ID  
                                    pid\_t                              shm\_cpid;                        //!> 创建进程的ID  
                                    shmatt\_t                        shm\_nattch;                  //!> 当前的附接数  
                                    shmatt\_t                        shm\_cnattch;                  //!> 内核的附接数  
                                    time\_t                              shm\_atime;                  //!> 最后一次关联时间  
                                    time\_t                              shm\_dtime;                  //!> 分离时间  
                                    time\_t                              shm\_ctime;                  //!> 最后一次改变时间  
                              \};                                           
       
                               
5.共享内存区的创建和操作：  
  
                               \#include<sys/types>  
                               \#include<sys/ipc.h>  
                               \#include<sys/shm.h>       
       
                               int shmget(key\_t key, size\_t size, int oflag );  
                               参数：  
                                          key:ftok返回值或者IPC\_PRIVATE  
                                          size:共享内存区大小( 字节为单位，if访问一个已经存在的，那么就是0 )  
                                           oflag:权限的组合(同前面讲的 )  
                         
                         
                              创建OK后，那么就可以使用shmat函数来链接到它的地址空间！  
                               void \*shmat( int shmid, const void \* addr, int flag);             
                                      //!> -------->链接共享区到哪个地址上与addr参数以及flag中是否指定SHM\_RND有关！  
                              //!> if addr == 0，那么连接到内核选择的第一个可用地址上  
                              //!> if addr!= 0 && 没有SHM\_RND，那么连接到addr上  
                              //!> if addr !=0 && 指定SHM\_RND，那么连接到addr-( addr modSHMLBA )上，SHM\_RND是取整意思  
                              //!>SHMLBA是指最低边界地址倍数。所以此算式表示靠近addr的一个边界地址上       
       
                              使用OK后就可以断开链接：shmdt函数  
                               int shmdt(const void \* addr);                                                      //!> 注意参数是shmat的返回值！！！  
                               
                               
                              最后要删除内存：shmctl函数  
                               int shmctl(int shmid, int cmd, struct shmid\_ds \* buff );  
                               参数：  
                                          shmid:就是创建或者打开是shmget函数的返回值  
                                          cmd:有多种取值  
                                          buff:主要用在IPC\_STAT取回结构体的值和IPC\_SET设置结构体值中使用！  
                                           cmd：  
                                                      IPC\_STAT:取得shmid\_ds的结构体，放在buff中  
                                                      IPC\_SET:按照buff设置结构体权限值->  sem\_perm.uid, sem\_perm.gid, sem\_perm.mode；注意其允许执行的权限进程( 与前面一样)  
                                                      IPC\_RMID:删除共享内存区，注意其删除是与文件inode差不多，只有当计数值为0才删除，否则仅仅是删除一个标志顺便计数器--就OK！  
                                                      SHM\_LOCK:锁住共享内存区，只有super用户权限才OK！  
                                                      SHM\_UNLOCK:      解锁，权限用户为super  
                                                 
**二.**  
**//-------------------------------------------------------------------------------------------------**  
**//简单的函数应用**  
  
  
//            创建实例  
  
\#include <stdio.h>  
\#include <sys/types.h>  
\#include <sys/ipc.h>  
\#include <stdlib.h>  
\#include <sys/shm.h>  
  
int main( int argc, char \*\* argv )  
\{  
       int             semid;  
       int             flag;  
      size\_t      len;  
  
       if( argc !=3 )                                          //!> 表示我们要输入2个字符串参数(因为第一个是默认的程序运行的全路径名 )  
       \{  
             printf("usage:shmget <pathname><length>\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
       len = atoi(argv\[2\] );                              //!> 第二个参数作为长度而已  
       flag =IPC\_CREAT;      //!> 创建标志( 具有唯一性 )------->注意IPC\_EXCL:决定了唯一性！ | IPC\_EXCL  
  
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.  
      //!> Create the sempore  
       if( ( semid= semget( ftok( argv\[1\], 'a' ), len, flag ) ) == -1 )  
       \{  
            printf("\\nCreate semaprore error...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
  
       printf("\\nThe semid = %d\\n", semid );  
             
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.  
      //!> Display attribute  
       intdis;  
       structshmid\_ds   buff\[10\];  
       if( ( dis =shmctl( semid, IPC\_STAT, buff ) ) == -1 )  
       \{  
             printf("\\nDisplay the attribute error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
  
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.  
      //!> Delete the semapore  
       intdel;  
       if( ( del =shmctl( semid, IPC\_RMID, NULL ) ) == -1 )  
       \{  
             printf("\\nDelete error... \\n");  
             exit(EXIT\_FAILURE );  
       \}  
  
       return0;  
\}  
  
**三：**  
**//-------------------------------------------------------------------------------------------------**  
**// 生产者与消费者**  
  
1.core简介：  
            我们可以知道在server(生产者)中我们给的最大的src就是5个，所以if我们仅仅是只执行serever，那么执行5次后必须要等待，因为P不到src了，但是if有client(消费者)存在，那么就可以，因为消费者消费OK后  
归还src，那么server又可以执行下去了。  
  
2.  
CODE：  
  
//           producer  
  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <string.h>  
\#include <fcntl.h>  
\#include <unistd.h>  
\#include <sys/types.h>  
\#include <sys/ipc.h>  
\#include <sys/sem.h>  
\#include <sys/shm.h>  
\#include <sys/stat.h>  
                     
\#define  MAXSHM            5                  //!> 定义缓冲区变量个数  
  
union semun                                          //!> 此处我们主要是为了SETVALUE使用  
\{  
       int                                    val;                  //!>设置信号的值                               
       structsemid\_ds\*            buf;            //!> buffer:IPC\_STAT, IPC\_SET  
       unsignedshort\*          array;            //!> GETALL, SETALL的数组  
\};  
  
int main()  
\{  
      key\_t            ipckey;                        //!> ipc 的 key  
      key\_t            semkey;                        //!> 信号量的key  
       
       int                  shmid;                              //!> ipc(此处是共享内存区模式导致)的ID  
       int                  semid;                              //!> 共享内存区ID  
       
      char\*            addr\_c;                        //!> 共享区的地址  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!>      对于共享区的处理(key   and  id   and   addr. )  
       
       ipckey =ftok( "/tmp/Linux/ipc", 368);                              //!> get ipc key  
       if( ipckey== -1 )  
       \{  
             printf("\\nCreate IPC key error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
       shmid =shmget( ipckey, 1024, IPC\_CREAT | 0666);      //!> get ipc id  
       if( shmid ==-1 )  
       \{  
             printf("\\nCreate IPC id error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
       addr\_c = (char \* )shmat( shmid, NULL, 0);                        //!> 链接到第一个可用的地址上  
       if( \*( ( int\* )addr\_c ) == -1)                                                //!> Set addr...  
       \{  
             printf("\\nSet addr. error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!>      对于信号量的处理(key    and   id)  
  
       structsembuf      P,  V;                                          //!> P  V        操作变量  
      union  semun             arg1, arg2,arg3;                  //!> 设置semid此信号集合中的三种信号量  
                                                                                    //!> 具体的下面有解释  
                                                                                     
       semkey =ftok( "/tmp/Linux/sem", 368);            //!> get sempore key  
       if( semkey== -1 )  
       \{  
             printf("\\nCeate sem. key error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
         
      //!> 请注意此处创建的一个信号量集合！  
      //!> 里面可以有不同的信号处理不同事件！！！！  
       semid =semget( semkey, 3, IPC\_CREAT | 0666);            //!> get sem. id  
                                                                                                      //!> 信号集合中信号为3种  
       if( semid< 0 )  
       \{  
             printf("\\nCreate sem. id error...\\n" );  
             exit(EXIT\_FAILURE );  
      \}       
  
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!>      初始化信号灯中信号量  
       
       
       
       arg1.val =0;                                                            //!> 缓冲区无数据，( 即信号满 )  
       if( semctl(semid, 0, SETVAL, arg1 ) == -1)      //!> 设置VALUE = arg1 = 0  
      \{                                                                              //!> sem 编号为0  
             printf("\\nSelValue (信号满) error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
       arg2.val =MAXSHM;                                          //!> 缓冲区 5 个空闲元素  
       if( semctl(semid, 1, SETVAL, arg2 ) == -1)      //!> 设置VALUE == arg2 = 5  
      \{                                                                              //!> sem 编号为1  
             printf("\\nSetValue (信号空) error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
       arg3.val =1;                                                            //!> 这个相当于是互斥使用缓冲区  
       if( semctl(semid, 2, SETVAL, arg3 ) == -1 )  
       \{  
             printf("\\nCreate 互斥缓冲区 error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!>       初始化P   V   操作  
       
       P.sem\_num =0;                                           
       P.sem\_op =-1;                                          //!> 注意：P的操作是 -- 操作( 就是-1处理)       
       P.sem\_flg =SEM\_UNDO;  
       
       V.sem\_num =0;  
       V.sem\_op=  1;                                          //!> 注意：V的操作是 ++ 操作( 就是+1处理 )  
       V.sem\_flg =SEM\_UNDO;  
       
                                                                        //!>下面进行的就是简单的PV操作       
       int i =0;             
       while( i< 10)                                          //!> 进行10次操作  
       \{  
             P.sem\_num =1;                                    //!> 注意P操作的是index=1的信号量  
                                                                        //!> 也就是存在元素的集合(--操作)  
             semop(semid, &P, 1);                        //!> 进行P操作一次  
             
             P.sem\_num =2;                                    //!> 此处是互斥操作信号量  
             semop(semid, &P, 1);                        //!> 只让一个进程操作，其他的等待  
             
             addr\_c\[i\] =i + 'a';                              //!> 仅仅是为了输出显示而已  
             printf("\\n产生空间   addr\_c\[%d\]   =%c   \\n", i, addr\_c\[i\]);  
             
             V.sem\_num =2;                                    //!> 对互斥操作进行V  
             semop(semid, &V, 1 );  
             
             V.sem\_num =0;                                    //!> P一个src后，就要加入开始没有元素的信号量中  
             semop(semid, &V, 1 );  
             
             i++;  
             sleep( 1);  
       \}  
  
       sleep( 60);  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!> 退出共享区失败  
       
       if( shmdt(addr\_c ) == -1)                                           
       \{  
             printf("\\n退出共享区失败\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
  
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!> 删除共享区  
       
       if( shmctl(shmid, IPC\_RMID, NULL ) == -1)             
       \{  
             printf("\\n删除共享区失败\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!> 删除信号集  
       
       if( semctl(semid, 0, IPC\_RMID, 0 ) == -1 )  
       \{  
             printf("\\n撤销信号集失败\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
  
       exit(EXIT\_SUCCESS );  
\}  
  
  
  
/           consumer  
  
\#include <stdio.h>  
\#include <string.h>  
\#include <stdlib.h>  
\#include <fcntl.h>  
\#include <sys/stat.h>  
\#include <sys/ipc.h>  
\#include <sys/sem.h>  
\#include <sys/shm.h>  
\#include <sys/types.h>  
  
\#define  MAXSHM                   5  
  
union semun                                          //!> 此处我们主要是为了SETVALUE使用  
\{  
       int                                    val;                  //!>设置信号的值                               
       structsemid\_ds\*            buf;            //!> buffer:IPC\_STAT, IPC\_SET  
       unsignedshort\*          array;            //!> GETALL, SETALL的数组  
\};  
  
int main()  
\{  
      key\_t            ipckey;  
      key\_t            semkey;  
       
       int                   shmid;  
       int                   semid;  
       
      char\*            addr\_c;  
  
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!> 得到IPC/SEM的key和id  
       
       ipckey =ftok( "/tmp/Linux/ipc", 368);                  //!> get ipc key  
       if( ipckey== -1 )  
       \{  
            printf("\\nCreate IPC key error...\\n");  
             exit(EXIT\_FAILURE );  
       \}  
       
       shmid =shmget( ipckey, 1024, IPC\_EXCL | 0666 );  
       if( shmid ==-1 )  
       \{  
             printf("\\nCreate IPC   ID error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
             
       addr\_c = (char \* )shmat( shmid, NULL, 0 );  
       if( \*( ( int\* ) addr\_c ) == -1 )  
       \{  
             printf("\\nCreate addr error...\\n" );  
             exit(EXIT\_FAILURE );  
      \}       
             
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!> 定义信号量的数据结构  
  
       structsembuf             P, V;  
       
       semkey =ftok( "/tmp/Linux/sem", 368 );  
       if( semkey== -1 )  
       \{  
            printf("\\nCreate sem. key error... \\n");  
             exit(EXIT\_FAILURE );  
       \}  
  
       semid =semget( semkey, 0, IPC\_EXCL | 0666);       
      //!> 在“生产者”中已经创建了，所以此处只要引用就好，所以第二参数0  
       if( semid< 0 )  
       \{  
             printf("\\nCreate sem. ID error...\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
       
      //!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  
      //!> 初始化P V 操作  
       
       P.sem\_num =0;  
       P.sem\_op =-1;                                    //!> 减去1操作  
       P.sem\_flg =SEM\_UNDO;  
       
       V.sem\_num =0;  
       V.sem\_op=  1;                                    //!> 加上1操作  
       V.sem\_flg =SEM\_UNDO;  
  
       int i =0;  
       while( i< 10 )  
       \{  
            //!> 先需要等待  
              P.sem\_num =0;                  //!> 注意开始我们知道这里面没有空间，  
                                                                    //!> 所以要等待server端的V操作，整体  
                                                                    //!> 看来我们知道，server P10次V10次，  
                                                                    //!> 此处就连续的读写就可以了  
              semop( semid, &P, 1 );  
               
              P.sem\_num =2;                              //!> 此处是互斥操作  
              semop( semid, &P, 1 );  
               
              printf("\\n消费空间 addr\_c\[%d\] = %c\\n", i,addr\_c\[i\]);     
               
              V.sem\_num =2;                              //!> 释放互斥区  
              semop( semid, &V, 1 );  
               
              V.sem\_num =1;                              //!> 那么 原来装有src信号量有了新的空间  
              semop( semid, &V, 1);                  //!> 也就是 ++ 处理  
               
              i++;  
              sleep( 2 );  
       \}  
  
      //!>>>>>>>>>>>>>>>>>>>>>>>>  
      //!>       下面释放链接  
       
       if( shmdt(addr\_c ) == -1 )  
       \{  
             printf("\\n退出共享区失败\\n" );  
             exit(EXIT\_FAILURE );  
       \}  
  
       exit(EXIT\_FAILURE );  
\}