登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›系统编程练习题---利用共享内存和信号量集，完成两个进 ...

系统编程练习题---利用共享内存和信号量集，完成两个进程之间的互斥通信

习和璧 2025-6-8 12:24:15
目录

  • 题目
  • 解析
  • 代码展示

    • process_A.c
    • process_B.c
    • process_C.c

  • 结果展示
  • 重要知识点记录

题目

设计一个程序，作为进程A，进程A专门创建一个信号量集，要求信号量集中有1个信号量，对信号量集合中的信号量进行设置，要求集合中的信号量的初值为1，然后再设计2个程序，分别是进程B和进程C，要求进程B和进程C使用进程A创建的信号量集合中的信号量实现互斥访问。  提示：进程A、进程B、进程C需要使用共享内存作为临界资源的访问。
解析

该题目核心设计思路是利用信号量集的P操作和V操作，实现进程B与进程C之间的互斥，避免进程B与进程C同时对共享内存段操作。三个进程文件具体分工如下：

  • 进程A用于创建并初始化信号量集与共享内存中的初始数据值
  • 进程B用于更改共享内存段中的数据值
  • 进程C用于输出共享内存段中的数据值
1.png

代码展示

process_A.c
  1. /*******************************************************************
  2. *
  3. *        file name:        process_A.c
  4. *        author         :  13316881233@163.com
  5. *        date         :  2024/05/28
  6. *        function :  该案例是掌握进程通信方式，主要是共享内存和信号量集的使用
  7. *                                进程A需要创建一个信号量集，该信号量集中有一个信号量，
  8. *                                 并要求该信号量的初值为1；进程A还需要创建一个共享内存段，
  9. *                                供给进程B和进程C进行访问操作
  10. *         note         :  None
  11. *   version  :
  12. *
  13. *        CopyRight (c)  2023-2024   13316881233@163.com   All Right Reseverd
  14. *
  15. * *****************************************************************/
  16. /****************************头文件**************************************/
  18. #include <stdio.h>
  19. #include <sys/shm.h>
  20. #include <sys/sem.h>
  21. #include <sys/types.h>
  22. #include <sys/ipc.h>
  23. #include <string.h>
  24. #include <errno.h>
  25. #include <stdlib.h>
  27. /****************************联合体**************************************/
  28. union semun
  29. {
  30.         int val;
  31.         struct semid_ds *buf;
  32.         unsigned short *array;
  33. } ;
  36. int main(int argc, char const *argv[])
  37. {
  38.         /****创建共享内存段，并完成数据的写入****/
  39.         //1. 申请共享内存段
  40.         int shm_id = shmget(ftok(".", 0xffffff01), 4, IPC_CREAT | IPC_EXCL | 0644);
  41.         if(shm_id == -1)
  42.         {
  43.                 fprintf(stderr, "shmget error, errno:%d, %s\n", errno, strerror(errno));
  44.                 shm_id = shmget(ftok(".", 0xffffff01), 4, 0644);
  45.         }
  46.         //2. 映射共享内存到进程A中
  47.         int *pshm = (int *)shmat(shm_id, NULL, 0);
  48.         if(pshm == (void*)-1)
  49.         {
  50.                 fprintf(stderr, "shmat error, errno:%d, %s\n", errno, strerror(errno));
  51.                 exit(-1);
  52.         }
  53.         //3. 向共享内存中写入数据
  54.         *pshm = 0;
  55.         //4. 分离共享内存段
  56.         int flag_dt = shmdt(pshm);
  57.         if(flag_dt == -1)
  58.         {
  59.                 fprintf(stderr, "shmdt error, errno:%d, %s\n", errno, strerror(errno));
  60.                 exit(-1);
  61.         }
  62.        
  65.         /****创建信号量集，并设置信号量集的信号量初值为1****/
  66.         //1. 创建信号量集
  67.         int sem_id = semget(ftok(".", 0xffffff01), 1, IPC_CREAT | IPC_EXCL | 0644);
  68.         if(sem_id == -1)
  69.         {
  70.                 fprintf(stderr, "sem_id error, errno:%d, %s\n", errno, strerror(errno));
  71.                 sem_id = semget(ftok(".", 0xffffff01), 1, 0644);
  72.         }
  73.         //2. 先获取信号集中的数据，再设置信号量初值为1
  74.         union semun arg;
  75.         arg.val = 1;
  76.         semctl(sem_id, 0,SETVAL,arg.val);
  78.         return 0;
  79. }
复制代码
process_B.c
  1. /*******************************************************************
  2. *
  3. *        file name:        process_B.c
  4. *        author         :  13316881233@163.com
  5. *        date         :  2024/05/28
  6. *        function :  该案例是掌握进程通信方式，主要是共享内存和信号量集的使用
  7. *                                需要将进程A创建的共享内存段映射到进程B中，方便后续写入数据；
  8. *                                进程B需要对进程A创建的信号量集交替进行P操作和V操作，来实现
  9. *                                对共享内存段中的数据互斥修改
  10. *         note         :  None
  11. *   version  :
  12. *
  13. *        CopyRight (c)  2023-2024   13316881233@163.com   All Right Reseverd
  14. *
  15. * *****************************************************************/
  16. /****************************头文件**************************************/
  18. #include <stdio.h>
  19. #include <sys/shm.h>
  20. #include <sys/sem.h>
  21. #include <sys/types.h>
  22. #include <sys/ipc.h>
  23. #include <string.h>
  24. #include <errno.h>
  25. #include <stdlib.h>
  26. #include <unistd.h>
  29. int main(int argc, char const *argv[])
  30. {
  31.         while(1)
  32.         {
  33.                 /****打开信号量集，完成P操作****/
  34.                 //1. 打开信号量集
  35.                 int sem_id = semget(ftok(".", 0xffffff01), 1, 0644);
  36.                 if(sem_id == -1)
  37.                 {
  38.                         fprintf(stderr, "sem_id error, errno:%d, %s\n", errno, strerror(errno));
  39.                         exit(-1);
  40.                 }
  41.                 //2. 定义结构体变量，并对结构体变量值完成相应配置
  42.                 struct sembuf semop_P;
  43.                 semop_P.sem_num = 0;        //该信号量集只有一个信号量，所以从下标0开始
  44.                 semop_P.sem_op = -1;        //操作值为负值，代表执行P操作，向信号量集申请资源
  45.                 semop_P.sem_flg = 0;        //由于题目要求进程B与进程C互斥，所以标志设为0，即默认阻塞模式
  46.                 //3. 对信号量集完成P操作
  47.                 semop(sem_id, &semop_P, 1);
  50.                 /****打开共享内存段，并完成数据的写入****/
  51.                 //1. 打开共享内存段
  52.                 int shm_id = shmget(ftok(".", 0xffffff01), 4, 0644);
  53.                 if(shm_id == -1)
  54.                 {
  55.                         fprintf(stderr, "shmget error, errno:%d, %s\n", errno, strerror(errno));
  56.                         exit(-2);
  57.                 }
  58.                 //2. 映射共享内存到进程B中
  59.                 int *pshm = (int *)shmat(shm_id, NULL, 0);
  60.                 if(pshm == (void*)-1)
  61.                 {
  62.                         fprintf(stderr, "shmat error, errno:%d, %s\n", errno, strerror(errno));
  63.                         exit(-3);
  64.                 }
  65.                 //3. 每次完成P操作后，将共享内存中的数据加一
  66.                 *pshm += 1;
  67.                 //4. 分离共享内存段
  68.                 int flag_dt = shmdt(pshm);
  69.                 if(flag_dt == -1)
  70.                 {
  71.                         fprintf(stderr, "shmdt error, errno:%d, %s\n", errno, strerror(errno));
  72.                         exit(-4);
  73.                 }
  74.                
  75.                 /****完成对共享内存中数据修改后，执行V操作****/
  76.                 //1. 定义结构体变量，并对结构体变量值完成相应配置
  77.                 struct sembuf semop_V;
  78.                 semop_V.sem_num = 0;        //该信号量集只有一个信号量，所以从下标0开始
  79.                 semop_V.sem_op = +1;        //操作值为正值，代表执行V操作，向信号量集归还资源
  80.                 semop_V.sem_flg = 0;        //由于题目要求进程B与进程C互斥，所以标志设为0，即默认阻塞模式
  81.                 //2. 对信号量集完成V操作
  82.                 semop(sem_id, &semop_V, 1);
  84.                 //为了方便观察结果，延迟一秒在进入循环
  85.                 sleep(1);
  86.         }
  88.         return 0;
  89. }
复制代码
process_C.c
  1. /*******************************************************************
  2. *
  3. *        file name:        process_C.c
  4. *        author         :  13316881233@163.com
  5. *        date         :  2024/05/28
  6. *        function :  该案例是掌握进程通信方式，主要是共享内存和信号量集的使用
  7. *                                需要将进程A创建的共享内存段映射到进程C中，方便后续读出数据；
  8. *                                进程C需要对进程A创建的信号量集交替进行P操作和V操作，来实现
  9. *                                对共享内存段中的数据互斥修改
  10. *         note         :  
  11. *             由于信号量集中的信号量初值设定为1，所以进程B与进程C的执行顺序
  12. *             会影响输出结果。若是想要从共享内存段中数据初值开始输出，则需要
  13. *             先执行进程C，在执行进程B
  14. *   version  :
  15. *
  16. *        CopyRight (c)  2023-2024   13316881233@163.com   All Right Reseverd
  17. *
  18. * *****************************************************************/
  19. /****************************头文件**************************************/
  21. #include <stdio.h>
  22. #include <sys/shm.h>
  23. #include <sys/sem.h>
  24. #include <sys/types.h>
  25. #include <sys/ipc.h>
  26. #include <string.h>
  27. #include <errno.h>
  28. #include <stdlib.h>
  29. #include <unistd.h>
  32. int main(int argc, char const *argv[])
  33. {
  34.         while(1)
  35.         {
  36.                 /****打开信号量集，完成P操作****/
  37.                 //1. 打开信号量集
  38.                 int sem_id = semget(ftok(".", 0xffffff01), 1, 0644);
  39.                 if(sem_id == -1)
  40.                 {
  41.                         fprintf(stderr, "sem_id error, errno:%d, %s\n", errno, strerror(errno));
  42.             exit(-1);
  43.         }
  44.         //2. 定义结构体变量，并对结构体变量值完成相应配置
  45.                 struct sembuf semop_P;
  46.                 semop_P.sem_num = 0;        //该信号量集只有一个信号量，所以从下标0开始
  47.                 semop_P.sem_op = -1;        //操作值为负值，代表执行P操作，向信号量集申请资源
  48.                 semop_P.sem_flg = 0;        //由于题目要求进程B与进程C互斥，所以标志设为0，即默认阻塞模式
  49.                 //3. 对信号量集完成P操作
  50.                 semop(sem_id, &semop_P, 1);
  52.                 /****打开共享内存段，并完成数据的输出****/
  53.                 //1. 打开共享内存段
  54.                 int shm_id = shmget(ftok(".", 0xffffff01), 4,  0644);
  55.                 if(shm_id == -1)
  56.                 {
  57.                         fprintf(stderr, "shmget error, errno:%d, %s\n", errno, strerror(errno));
  58.             exit(-2);
  59.         }
  60.         //2. 映射共享内存到进程B中
  61.                 int *pshm = (int *)shmat(shm_id, NULL, 0);
  62.                 if(pshm == (void*)-1)
  63.                 {
  64.                         fprintf(stderr, "shmat error, errno:%d, %s\n", errno, strerror(errno));
  65.                         exit(-3);
  66.                 }
  67.                 //3. 每次完成P操作后，将共享内存段中的数据输出到终端上
  68.         printf("data = %d\n", *pshm);
  69.         // 4. 分离共享内存段
  70.         int flag_dt = shmdt(pshm);
  71.                 if(flag_dt == -1)
  72.                 {
  73.                         fprintf(stderr, "shmdt error, errno:%d, %s\n", errno, strerror(errno));
  74.                         exit(-4);
  75.                 }
  76.                
  77.                 /****完成对共享内存中数据输出后，执行V操作****/
  78.                 //1. 定义结构体变量，并对结构体变量值完成相应配置
  79.                 struct sembuf semop_V;
  80.                 semop_V.sem_num = 0;        //该信号量集只有一个信号量，所以从下标0开始
  81.                 semop_V.sem_op = +1;        //操作值为正值，代表执行V操作，向信号量集归还资源
  82.                 semop_V.sem_flg = 0;        //由于题目要求进程B与进程C互斥，所以标志设为0，即默认阻塞模式
  83.                 //2. 对信号量集完成V操作
  84.                 semop(sem_id, &semop_V, 1);
  86.                 //为了方便观察结果，延迟一秒在进入循环
  87.                 sleep(1);
  88.         }
  90.         return 0;
  91. }
复制代码
结果展示

2.png

重要知识点记录

修改信号量集中的信号量的初值，需要使用到SETVAL标识，具体操作如下图：
3.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
习和璧
2025-6-8 12:24:15

0

粉丝关注

18

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫