UNIX/LINUX编程学习之进程通信--共享内存

最新推荐文章于 2020-12-08 14:12:01 发布
最新推荐文章于 2020-12-08 14:12:01 发布
阅读量449 收藏
点赞数
分类专栏： UNIX/LINUX学习 文章标签： 编程 struct cmd 工具 c

转自：
http://shihaiyang.iteye.com/blog/493555

共享内存(Shared Memory) 
共享内存，简单的说就是被多个进程共享的内存。它在各种进程通信方法中是最快的，因为它是将信息直接映射到内存中， 

省去了其它 IPC方法的中间步骤。 
1.shmid_ds 
共享内存也有一个给系统内存用来保存相关信息的机构，就是shmid_ds。 

C代码   收藏代码
  1. struct shmid_ds{  
  2. struct ipc_perm shm_perm;                //operation  
  3. int     shm_segsz;            //size of segment  
  4. _kernel_time_t  shm_atime;            //last attach time  
  5. _kernel_time_t  shm_dtime;            //last detach time      
  6. _kernel_time_t  shm_ctime;            //last change time  
  7. _kernel_ipc_pid_t   shm_cpid;     //pid of creator  
  8. _kernel_ipc_pid_t   shm_lpid      //pid of last operator  
  9. unsigned short      shm_nattch;   //no. of current attaches  
  10. unsigned short      shm_unused;   //compatibility  
  11. void            *shm_unused2; //ditto - used by DIPC  
  12. void            *shm_unused3; //unused  
  13. }  


其中： 
shm_perm    成员储存了共享内存对象的存取权限及其它一些信息。 
shm_segsz   成员定义了共享的内存大小（以字节为单位）。 
shm_atime   成员保存了最近一次进程连接共享内存的时间。 
shm_dtime   成员保存了最近一次进程断开与共享内存的连接的时间。 
shm_ctime   成员保存了最近一次 shmid_ds 结构内容改变的时 
shm_cpid     成员保存了创建共享内存的进程的 pid。 
shm_lpid      成员保存了最近一次连接共享内存的进程的 pid。 
shm_nattch  成员保存了与共享内存连接的进程数目。 
剩下的三个成员被内核保留使用，这里就不介绍了。 

有关的函数 
1、sys_shmget()函数 
使用shmget()函数来创建新的获取得已有的共享内存。 
系统调用：shmget() 
函数声明：int shmget(key_t key,int size,int shmflg); 
    返回值：shared memory segment identigier on success 
                 -1 on error: errno = 

shmget()函数的第一个参数key 是共享内存的关键字；第二个参数 size 是创建的共享内存的大小，以字节为单位。第三个参 

数 shmflg 是控制函数行为的标志量，其取值的含义和作用和 msgget()及semget()函数的对应参数都是相同的. 

C代码   收藏代码
  1. int open_shm(key_t keyval, int segsize)  
  2. {  
  3.     int shmid;  
  4.     if(shmid=shmget(keyval, segsize,IPC_CREAT|0660))==-1)  
  5.     {  
  6.         return(-1);  
  7.     }  
  8.     return(shmid);  
  9. }  


2、shmat()函数 
当一个进程使用 shmget()函数得到了共享内存的标识符之后，就可以使用shmat()函数来将共享内存映射到进程自己的内 

存空间内。 
系统调用：shmat() 
函数声明： int shmat(int shmid, char *shmaddr, int shmflg); 
    返回值： address at which segment was attached to the process, or 
                 -1 on error: errno = 
第一个参数是共享内存的标识符。 
第二个参数 shmaddr 指定了共享内存映射的地址。因为这样必须要预先分配内存，十分不便，所以我们在使用时常常将这 

个参数置零，这样系统会自动为映射分配一块未使用的内存。如果指定了地址，可以给第三个参数 shmflg 指定SHM_RND 

标志来强迫将内存大小设定为页面的尺寸。 
如果指定了 SHM_RDONLY参数，共享内存将被映射成只读。 
映射成功后，函数返回指向映射内存的指针。 
下面的这段代码演示了 shmat()函数的使用： 
C代码   收藏代码
  1. char *attach_segment( int shmid )  
  2. {  
  3.          return(shmat(shmid, 0, 0));  
  4. }  
得到了映射内存的指针之后，我们就可以像读写普通内存一样对共享内存进行读写了。 

3、shmctl()函数 
和前两个 IPC 对象一样，共享内存也有一个直接对其进行操作的函数，就是 shmctl()函数。 
系统调用： shmctl() 
函数声明：int shmctl(int shmqid, int cmd, struct shmid_ds *buf); 
    返回值：0 on success 
-1 on error: errno = 

这个函数和 msgget()函数十分相似，用法也相同。它支持的操作有： 
IPC_STAT   获得共享内存的信息。 
IPC_SET   设定共享内存的信息。 
IPC_RMID   删除共享内存。 
需要说明的是，当执行 IPC_RMID 操作时，系统并不是立即将其删除，而只是将其标为待删，然后等待与其连接的进程断开连接。只有当所有的连接都断开以后系统才执行真正的删除操作。当然，如果执行 IPC_RMID 的时候没有任何的连接，删除将是立即的。 

4、shmdt()函数 
当一个进程不再需要某个共享内存的映射时，就应该使用 shmdt()函数断开映射。 
系统调用： shmdt() 
函数声明： int shmdt ( char *shmaddr ); 
    返回值： -1 on error: errno = EINVAL (Invalid attach address passed) 
shmdt()函数唯一的参数是共享内存映射的指针。 

共享内存应用举例——shmtool,交互式的共享内存使用工具 
C代码   收藏代码
  1. shmtool.c  
  2.   
  3. #include <sys/types.h>  
  4. #include <sys/ipc.h>  
  5. #include <sys/shm.h>  
  6.   
  7. #define SEGSIZE 100  
  8. writeshm(int shmid, char *segptr, char *text)  
  9. {  
  10.     strcpy(segptr, text);  
  11.     printf("Done..\n");  
  12. }  
  13.       
  14. readshm(int shmid, char *segptr)  
  15. {  
  16.     printf("segptr: %s\n", segptr);  
  17. }  
  18.       
  19. removeshm(int shmid)  
  20. {  
  21.     shmctl(shmid, IPC_RMID, 0);  
  22.     printf("Shared memory segment marked for deletion\n");  
  23. }  
  24.   
  25. changemode(int shmid, char *mode)  
  26. {  
  27.     struct shmid_ds myshmds;  
  28.   
  29.     /*Get current values for internal data structure */  
  30.     shmctl(shmid, IPC_STAT, &myshmds);  
  31.           
  32.     /* Display old permissions */  
  33.     printf("Old permissions were:%o\n", myshmds.shm_perm.mode);  
  34.   
  35.     /*Convert and load the mode */  
  36.     sscanf(mode, "%o", &myshmds.shm_perm.mode);  
  37.           
  38.     /* Update the mode */  
  39.     shmctl(shmid, IPC_SET, &myshmds);  
  40.   
  41.     printf("New permissions are: %o", myshmds.shm_perm.mode);  
  42.   
  43. }  
  44. usage()  
  45. {  
  46.             fprintf(stderr, "shmtool - A utility for tinkering with shared memory\n");  
  47.             fprintf(stderr, "\nUSAGE:  shmtool (w)rite <text>\n");  
  48.             fprintf(stderr, "                (r)ead\n");  
  49.             fprintf(stderr, "                (d)elete\n");  
  50.             fprintf(stderr, "                (m)ode change <octal mode>\n");  
  51.             exit(1);  
  52. }  
  53. main(int argc, char *argv[])  
  54. {  
  55.     key_t key;  
  56.     int     shmid,cntr;  
  57.     char  *segptr;  
  58.     if(argc==1) usage();  
  59.       
  60.     /*Create unique key via call to ftok() */  
  61.     key =ftok(".", 'S');  
  62.   
  63.     /*Open the shared memory segment -create if necessary */  
  64.     if((shmid =shmget(key, SEGSIZE, IPC_CREAT|IPC_EXCL|0666))==-1)  
  65.     {  
  66.         printf("Shared memory segment exists - opening as client\n");  
  67.         /* Segment probably already exists - try as client */  
  68.         if((shmid = shmget(key, SEGSIZE, 0))==-1)  
  69.         {  
  70.             perror("shmget");  
  71.             exit(1);  
  72.         }  
  73.   
  74.   
  75.     }  
  76.     else{  
  77.         printf("Creating new shared memory segment\n");  
  78.   
  79.     }  
  80.       
  81.     /* Attach (map) the shared memory segment into the current process */  
  82.     if((segptr= shmat(shmid,0,0))==-1)  
  83.     {  
  84.         perror("shmat");  
  85.         exit(1);  
  86.   
  87.     }  
  88.       
  89.     switch(tolower(argv[1][0]))  
  90.     {  
  91.         case 'w':   
  92.         writeshm(shmid, segptr, argv[2]);  
  93.                             break;  
  94.         case 'r':   
  95.         readshm(shmid, segptr);  
  96.                             break;  
  97.                     case 'd':   
  98.         removeshm(shmid);  
  99.                             break;  
  100.                     case 'm':   
  101.         changemode(shmid, argv[2]);  
  102.                             break;  
  103.                     default: usage();  
  104.   
  105.     }  
  106.       
  107. }  
  108.   
  109. /home/l/g/tomotoboy/ipc/shm >shmtool r  
  110. Shared memory segment exists - opening as client  
  111. segptr: test  
  112. /home/l/g/tomotoboy/ipc/shm >shmtool w "hello:this is a test"  
  113. Shared memory segment exists - opening as client  
  114. Done..  
  115. /home/l/g/tomotoboy/ipc/shm >shmtool r  
  116. Shared memory segment exists - opening as client  
  117. segptr: hello:this is a test  
  118. /home/l/g/tomotoboy/ipc/shm >shmtool d  
  119. Shared memory segment exists - opening as client  
  120. Shared memory segment marked for deletion  
  121. /home/l/g/tomotoboy/ipc/shm >shmtool r  
  122. Creating new shared memory segment  
  123. segptr:  

油条蘸甜豆浆
关注
专栏目录
Unix-Linux编程实践教程(中文清晰带书签).pdf
01-06
4. **进程管理**：掌握如何创建、控制和通信进程（如fork、exec、wait、pipe和socket等），是Unix/Linux编程的核心内容。 5. **系统调用**：如open、read、write、close用于文件操作，fork和exec用于进程创建，...
UNIX/Linux 编程实践教程源代码part1（至11章））
01-07
学习如何创建子进程（fork）、进程间通信（pipe、socket、信号量、共享内存等）以及进程调度是非常重要的。 3. **文件系统操作**：I/O操作是编程的基础，包括打开、关闭、读写文件，以及文件权限和路径的处理。源...
通过共享内存进行进程间通信
liangkaiming的专栏
03-11 6534
<br />共享内存的工作方式<br />顾名思义，共享内存让一段内存可供多个进程访问。用特殊的系统调用（即对 UNIX 内核的请求）分配和释放内存并设置权限；通过一般的读写操作读写内存段中的数据。 <br />共享内存并不是从某一进程拥有的内存中划分出来的；进程的内存总是私有的。共享内存是从系统的空闲内存池中分配的，希望访问它的每个进程连接它。这个连接过程称为映射，它给共享内存段分配每个进程的地址空间中的本地地址。<br /> 假设在同一系统上有两个进程 A 和 B 正在运行（见 图 1），它们可以通过共
共享内存实现进程间通讯
深之JohnChen的专栏
03-24 3092
进程通常被定义为一个正在运行的程序的实例，它由两个部分组成：一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方。另一个是地址空间，它包含所有的可执行模块或DLL模块的代码和数据。它还包含动态分配的空间。如线程堆栈和堆分配空间。每个进程被赋予它自己的虚拟地址空间，当进程中的一个线程正在运行时，该线程可以访问只属于它的进程的内存。属于其它进程的内存则是隐藏的，并不能
共享内存用于进程间通信
linuxcpp_的博客
12-08 113
共享内存用于进程间通信共享内存在父子进程间通信示例共享内存在无血缘关系进程间通信写端示例读端示例 共享内存在父子进程间通信 示例 /* * function: 演示使用mmap()函数实现使用共享映射区完成父子进程间通信 * * 2020-12-07 */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <fcntl.
共享内存 进程间通信
ZhY_Rening的博客
12-22 296
共享内存 进程间通信
UNIX环境高级编程_Linux/Unix编程_
09-30
了解如何有效地管理内存是UNIX/Linux编程的关键。书中会讲解动态内存分配（malloc、calloc、realloc、free等），以及内存映射（mmap）和内存对齐等概念。 八、系统接口和系统调用 书中将详细阐述系统调用接口，包括...
Linux-C-program.rar_Linux/Unix编程
09-20
通过学习这个文档，你可以掌握在Linux和Unix系统中使用C语言进行进程通信和消息管理的基本技能，这对于系统级编程和开发高效、可靠的多进程应用程序至关重要。无论是对初学者还是有经验的开发者，理解并熟练运用这些...
UNIX.rar_Linux/Unix编程_Unix_Linux_
08-11
- Unix/Linux提供了多种进程间通信方式，如管道（pipe）、FIFO（有名管道）、信号量、消息队列、共享内存、套接字（socket）等。 - 学习如何利用这些机制实现进程间的协调和数据交换。 8. **Socket程序设计**： ...
进程间通信之共享内存
Travelerwz的博客
08-08 656
进程间通信之共享内存 一、共享内存的介绍 共享内存可以从字面上去理解，就把一片逻辑内存共享出来，让不同的进程去访问它，修改它。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一...
进程间通讯之共享内存
IT_model的博客
03-25 7089
进程间通讯之共享内存一、引言：管道、信号、信号量虽然满足了进程之间通讯的需要，但是还有一种没有满足，那就是进程之间需要共享大量的数据。就像一家人一样，他们彼此之间每天都在交流，但是对于家里面的一些共有物品，如电视，餐厅等等都是共享的，而我们所说的进程之间也是一样的，他们虽然互相独立存在，但是还有很多数据都是共享使用的，而进程之间的数据共享就是共享内存。二、共享内存理论及其分析：共享内存就是两个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值