• Linux进阶-ipc共享内存

    目录

    共享内存

    shmget()：创建或获取共享内存

    shmat()：映射

    shmdt()：解除映射

    shmctl()：获取或设置属性

    sem.h文件

    sem.c文件

    shm.c文件

    Makefile文件

    执行过程

    共享内存

    共享内存：将内存进行共享，它允许多个不相关的进程访问同一个逻辑内存，直接将一块裸露的内存放在需要数据传输的进程前，供进程使用。

    因此，共享内存是效率最高的一种IPC通信机制，可以在多个进程间共享和传递数据，进程间需要共享的数据被放在共享内存区域，所有需要访问该共享内存的进程都要把该共享区域映射到本进程的地址空间中，因此所有进程都可访问共享内存的地址。

    但是，共享内存需要进程自己去维护，如同步、互斥等。如进程1在读取共享内存的数据时，进程2却修改了共享内存的数据，这会导致数据混乱。因此共享内存属于临界资源，在某一时刻只能有一个进程对其操作（读写）。共享内存一般不能单独使用，而是配合信号量、互斥锁等协调机制，让各个进程在高效交换数据时，不会发生数据践踏、破坏等行为。

    共享内存思想：进程间虚拟内存空间本来相互独立，不能相互访问，但是可以通过某种方式使得相同的一块物理内存多次映射到不同的进程虚拟空间中，相当于多个进程的虚拟内存空间部分重叠在一起。共享内存少了拷贝的操作，减少了系统开销，因此效率极高。

    shmget()：创建或获取共享内存

    shmget()函数会创建或获取一个共享内存对象，并返回共享内存标识符。

    1. #include 
    2. #include 
    3. int shmget(key_t key, size_t size, int shmflg);
    4. /*
    5. key：共享内存的标识符
    6.     IPC_PRIVATE：创建一块新的共享内存
    7.     0：当shmflg参数设置了IPC_PRIVATE标志，则将创建一块新的共享内存
    8.     大于0的32位整数：根据shmflg参数来确定操作
    9. size：要创建共享内存的大小，所有的内存分配操作都是以页为单位的，所有即使只申请一个字节的内存，内存也会分配一页。
    10. shmflg：表示创建的共享内存的模式标志参数。标志 | mode
    11.     IPC_CREAT：如果内核中不存在关键字与key相等的共享内存，则新建一个共享内存；如果存在则返回此共享内存的标识符。
    12.     IPC_EXCL：如果内核中不存在关键字与key相等的共享内存，则新建一个共享内存；如果存在则报错
    13.     SHM_HUGETLB：使用“大页面”来分配共享内存，所谓的“大页面”指的是内核为了提高程序性能，对内存实行分页管理时，采用比默认尺寸（4KB）更大的分页，以减少缺页中断。 Linux 内核支持以 2MB 作为物理页面分页的基本单位。
    14.     SHM_NORESERVE：不在交换分区中为这块共享内存保留空间。
    15. 返回值：共享内存的ID。
    16. */

    当调用shmget()函数失败时将产生错误代码：

            EACCES：指定的消息队列已存在，但调用进程没有权限访问它

            EEXIST：key指定的消息队列已存在，而msgflg中同时指定IPC_CREAT和IPC_EXCL标志

            EINVAL：创建共享内存是参数size小于SHMMIN或大于SHMMAX

            ENFILE：已达到系统范围内打开文件总数的限制

            ENOENT：给定的key不存在任何共享内存，并且未指定IPC_CREAT

            ENOMEM：内存不足，无法为共享内存分配内存

    shmat()：映射

    shmat()函数是把共享内存区域对象映射到调用进程的地址空间。

    1. #include 
    2. #include 
    3. void *shmat(int shmid, const void *shmaddr, int shmflg);
    4. /*
    5. shmid：共享内存ID
    6. shmaddr：如果不为NULL，则系统会根据shmaddr来选择一个合适的内存区域；如果为NULL，则系统会自动选择一个合适的虚拟内存空间地址去映射共享内存
    7. shmflg：
    8.     SHM_RDONLY：以只读方式映射共享内存
    9.     SHM_REMAP：重新映射，此时shmaddr不能为NULL
    10.     NULLSHM：自动选择比shmaddr小的最大页对齐地址
    11. 返回值：共享内存的起始地址。
    12. */

    共享内存的映射需注意：

    共享内存只能以只读或可读写方式映射，无法以只写方式映射。

    shmaddr参数一般设置为NULL，让系统自动地寻找合适的地址。当不为NULL时，SHMFLG必须设置为SHM_RND，系统将会选择比shmaddr小而又最大的页对齐地址（即为SHMLBA的整数倍）作为共享内存区域的起始地址。如果没有设置SHM_RND，那么shmaddr必须是严格的页对齐地址。

    shmdt()：解除映射

    shmdt()函数是解除进程和共享内存间的映射。

    1. #include 
    2. #include 
    3. void shmdt(const void *shmaddr);
    4. /*
    5. shmaddr：映射的共享内存的起始地址
    6. 返回值：
    7.     执行成功：0
    8.     执行失败：-1，并将错误原因存于errno
    9. */

    注意：该函数并不删除所指定的共享内存区，而只是将先前用shmat()函数映射好的共享内存脱离当前进程，共享内存还是存在于物理内存中。

    shmctl()：获取或设置属性

    shmctl()函数用于获取或设置共享内存的相关属性。

    1. #include 
    2. #include 
    3. int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    4. /*
    5. shmid：共享内存标识符
    6. cmd：
    7.     IPC_STAT：获取属性信息，放置到 buf 中。
    8.     IPC_SET：设置属性信息为 buf 指向的内容。
    9.     IPC_RMID：删除该共享内存。
    10.     IPC_INFO：获得关于共享内存的系统限制值信息。
    11.     SHM_INFO：获得系统为共享内存消耗的资源信息。
    12.     SHM_STAT：与 IPC_STAT 具有相同的功能，但 shmid 为该 SHM 在内核中记录所有 SHM 信息的数组的下标，因此通过迭代所有的下标可以获得系统中所有 SHM 的相关信息。
    13.     SHM_LOCK：禁止系统将该 SHM 交换至 swap 分区。
    14.     SHM_UNLOCK：允许系统将该 SHM 交换至 swap 分区。
    15. buf：共享内存属性信息结构体指针，设置或者获取信息都通过该结构体
    16. */

    一个SHM被交换至swap分区后如果被设置了SHM_LOCK，那么任何访问这个SHM的进程都将会遇到页错误。进程可以通过IPC_STAT后得到的mode来检测SHM_LOCKED信息。

    1. struct shmid_ds {
    2.     struct ipc_perm shm_perm;     /* 所有权和权限 */
    3.     size_t shm_segsz;             /* 共享内存尺寸（字节） */
    4.     time_t shm_atime;             /* 最后一次映射时间 */
    5.     time_t shm_dtime;             /* 最后一个解除映射时间 */
    6.     time_t shm_ctime;             /* 最后一次状态修改时间 */
    7.     pid_t shm_cpid;               /* 创建者 PID */
    8.     pid_t shm_lpid;               /* 后一次映射或解除映射者 PID */
    9.     shmatt_t shm_nattch;          /* 映射该 SHM 的进程个数 */
    10.     ...
    11. };
    12.  
    13. struct ipc_perm {
    14.     key_t __key;           /* 该共享内存的键值 key */
    15.     uid_t uid;             /* 所有者的有效 UID */
    16.     gid_t gid;             /* 所有者的有效 GID */
    17.     uid_t cuid;            /* 创建者的有效 UID */
    18.     gid_t cgid;            /* 创建者的有效 GID */
    19.     unsigned short mode;   /* 读写权限 + SHM_DEST + SHM_LOCKED 标记 */
    20.     unsigned short __seq;  /* 序列号 */
    21. };

    sem.h文件

    1. #ifndef __SEM_H
    2. #define __SEM_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15.  
    16. int init_sem(int sem_id, int init_value);
    17. int del_sem(int sem_id);
    18. int sem_p(int sem_id);
    19. int sem_v(int sem_id);
    20.  
    21. #endif

    sem.c文件

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. union semun
    14. {
    15.         int val;                //供semctl()函数cmd = SETVAL时使用
    16.         struct semid_ds *buf;   //供semctl()汉斯cmd = IPC_STAT|IPC_SET时使用
    17. };
    18.  
    19. /* 初始化信号量 */
    20. int init_sem(int sem_id, int init_value)
    21. {
    22.         union semun sem_union;
    23.  
    24.         sem_union.val = init_value;
    25.  
    26.         /* 信号量ID，信号量编号，命令，联合体 */
    27.         if( semctl( sem_id, 0, SETVAL, sem_union) == -1 )
    28.         {
    29.                 printf("Initialize semaphore error!\n");
    30.                 return -1;
    31.         }else
    32.         {
    33.                 printf("Initialize semaphore!\n");
    34.         }
    35. }
    36.  
    37. /* 删除信号量 */
    38. int del_sem(int sem_id)
    39. {
    40.         union semun sem_union;
    41.  
    42.         /* 信号量ID，信号量编号，命令，联合体 */
    43.         if( semctl( sem_id, 0, IPC_RMID, sem_union) == -1 )
    44.         {
    45.                 printf("Delete semaphore error!\n");
    46.                 return -1;
    47.         }else
    48.         {
    49.                 printf("Delete semaphore!\n");
    50.         }
    51. }
    52.  
    53. /* p操作 */
    54. int sem_p(int sem_id)
    55. {
    56.         struct sembuf sops;
    57.  
    58.         sops.sem_num = 0;               //信号量的编号：0～nsems-1
    59.         sops.sem_op  = -1;              //表示p操作
    60.         sops.sem_flg = SEM_UNDO;        //系统自动释放在系统中残留的信号量
    61.  
    62.         /* 信号量ID，结构体，信号量数量 */
    63.         if( semop( sem_id, &sops, 1) == -1 )
    64.         {
    65.                 perror("p operation error!\n");
    66.                 return -1;
    67.         }else
    68.         {
    69.                 printf("p operation successful!\n");
    70.                 return 0;
    71.         }
    72. }
    73.  
    74. /* v操作 */
    75. int sem_v(int sem_id)
    76. {
    77.         struct sembuf sops;
    78.  
    79.         sops.sem_num = 0;               //信号量的编号：0～nsems-1
    80.         sops.sem_op  = 1;               //表示v操作
    81.         sops.sem_flg = SEM_UNDO;        //系统自动释放在系统中残留的信号量
    82.  
    83.         /* 信号量ID，结构体，信号量数量 */
    84.         if( semop( sem_id, &sops, 1) == -1 )
    85.         {
    86.                 perror("v operation error!\n");
    87.                 return -1;
    88.         }else
    89.         {
    90.                 printf("v operation successful!\n");
    91.                 return 0;
    92.          }
    93. }

    shm.c文件

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include "sem.h"
    13.  
    14. int main(int argc, char** argv)
    15. {
    16.         int sem_id, shm_id;
    17.         char *addr;
    18.         pid_t pid;
    19.  
    20.         /* 创建信号量：键值，数量，模式 */
    21.         sem_id = semget((key_t)0x1100, 1, IPC_CREAT|0666);
    22.         /* 创建共享内存：键值，共享内存大小，模式 */
    23.         shm_id = shmget((key_t)0x1111, 1024, IPC_CREAT|0666);
    24.  
    25.         /* 初始化信号量 */
    26.         init_sem(sem_id, 0);
    27.  
    28.         if( ( pid = fork() ) == -1)
    29.         {
    30.                 perror("rork error!\n");
    31.         }else if(pid == 0)      //子进程
    32.         {
    33.                 printf("Child process will wait for some seconds...\n");
    34.                 sleep(3);
    35.  
    36.                 /* 映射共享内存，映射地址系统自动分配 */
    37.                 if( ( addr = shmat(shm_id, NULL, 0) ) == (void *)-1 )
    38.                 {
    39.                         printf("child shmat error!\n");
    40.                         exit(-1);
    41.                 }
    42.  
    43.                 memcpy(addr, "hello couvrir", 14);
    44.                 printf("the child process is running...\n");
    45.                 sem_v(sem_id);
    46.         }else                   //父进程
    47.         {
    48.                 sem_p(sem_id);
    49.                 printf("the father process is running...\n");
    50.  
    51.                 /* 映射共享内存，映射地址系统自动分配 */
    52.                 if( ( addr = shmat(shm_id, NULL, 0) ) == (void *)-1 )
    53.                 {
    54.                         printf("father shmat error!\n");
    55.                         exit(-1);
    56.                 }
    57.  
    58.                 printf("share memory string:%s\n", addr);
    59.  
    60.                 /*解除共享内存映射*/
    61.                 shmdt(addr);
    62.  
    63.                 sem_v(sem_id);
    64.                 del_sem(sem_id);
    65.         }
    66.  
    67.         exit(0);
    68. }

    Makefile文件

    照旧

    执行过程

  • 相关阅读:
    【元宇宙欧米说】众神时代——游戏与区块链结合，重构游戏产业新面貌
    小谈设计模式（15）—观察者模式
    Windows Server 2012 R2系统远程桌面的数字证书算法SHA1升级到SHA256
    金融信创局面已打开，如何建设国产化文件传输系统？
    hadoop的yarn部署
    java计算机毕业设计汉服配饰销售系统源码+mysql数据库+系统+LW文档+部署
    【Linux】项目自动化构建工具 - make/Makefile
    四、LockSupport与线程中断
    物联网基础建设-园区智能微电网设计方案
    初识Python_数据容器_字符串str
  • 原文地址：https://blog.csdn.net/weixin_47077788/article/details/133887452