抽烟者问题

一、问题描述

   抽烟者问题。假设一个系统中有三个抽烟者进程,每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料:烟草、纸和胶水。一个抽烟者有烟草,一个有纸,另一个有胶水。系统中还有两个供应者进程,它们无限地供应所有三种材料,但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者,让它继续提供另外的两种材料。这一过程重复进行。 请用以上介绍的 IPC 同步机制编程,实现该问题要求的功能。

二、问题分析

  这个问题主要涉及到操作系统中的进程见的同步与互斥的,是一个非常经典的问题。可以看做是生产者消费者这一类。

  三个抽烟者相当于三个不同的消费者,他们每次只会有一个抽烟者可以抽到烟,其余两个则需要等待。而在这里默认空间大小只有一个单元,即供应者每次放下两种材料后都会停下来等待直到有消费者使用了这两种材料,他才会继续放另两种材料。相当于说缓冲区的大小为1。为了方便起见,我们把要放的两种材料捆绑到一起,看成一个单位,分别用A、B、C表示,三个吸烟着分别用1,2,3号表示。

三、画出大致的操作流程和关键代码

 

抽烟者问题_第1张图片

设置五个信号量分别为三个抽烟者对应的glue、tobacco、paper和与供应者相应的同步信号量表示缓存区为空的empty信号量。最后还有一个保证临界资源安全访问的互斥信号量mutex。

供应者:                  1号抽烟者:               2号抽烟者:                  3号抽烟者:

while(1)                    while(1)                       while(1)                          while(1)

{                                 {                                   { {

p(empty);                  p(glue);                          p(tobacco); p(paper);

p(mutex);                  p(mutex);                      p(mutex); p(mutex);

供应材料。                抽烟                              抽烟 抽烟

v(mutex)                    v(mutex);                      v(mutex); v(mutex);

if(材料为A)           v(empty);                        v(empty); v(empty);

v(glue)                        }                                } }

if(材料为B)

v(tobacco)

if(材料为C)

v(paper)

}   

信号量的初始值:

empty=1;mutex=1;glue=0;paper=0;tobacco=0;                         

四、具体代码

ipc.h:


   
   
   
   
  1. /*
  2. * Filename
  3. : ipc.h
  4. * copyright
  5. : (C) 2006 by zhonghonglie
  6. * Function
  7. : 声明 IPC 机制的函数原型和全局变量
  8. */
  9. #include
  10. #include
  11. #include
  12. #include
  13. #include
  14. #include
  15. #include
  16. #define BUFSZ 256
  17. //建立或获取 ipc 的一组函数的原型说明
  18. int get_ipc_id(char *proc_file,key_t key);
  19. char *set_shm(key_t shm_key,int shm_num,int shm_flag);
  20. int set_msq(key_t msq_key,int msq_flag);
  21. int set_sem(key_t sem_key,int sem_val,int sem_flag);
  22. int down(int sem_id);
  23. int up(int sem_id);
  24. /*信号灯控制用的共同体*/
  25. typedef union semuns {
  26. int val;
  27. } Sem_uns;
  28. /* 消息结构体*/
  29. typedef struct msgbuf {
  30. long mtype;
  31. char mtext[ 1];
  32. } Msg_buf;
  33. //生产消费者共享缓冲区即其有关的变量
  34. key_t buff_key;
  35. int buff_num;
  36. char *buff_ptr;
  37. //生产者放产品位置的共享指针
  38. key_t pput_key;
  39. int pput_num;
  40. int *pput_ptr;
  41. //消费者取产品位置的共享指针
  42. key_t cget_key;
  43. int cget_num;
  44. int *cget_ptr;
  45. //生产者有关的信号量
  46. key_t tobacco_key;
  47. key_t glue_key;
  48. key_t paper_key;
  49. int tobacco_sem;
  50. int glue_sem;
  51. int paper_sem;
  52. //消费者有关的信号量
  53. key_t empty_key;
  54. key_t mutex_key;
  55. int empty_sem;
  56. int mutex_sem;
  57. int sem_val;
  58. int sem_flg;
  59. int shm_flg;
  60. /*
  61. * Filename
  62. : ipc.h
  63. * copyright
  64. : (C) 2006 by zhonghonglie
  65. * Function
  66. : 声明 IPC 机制的函数原型和全局变量
  67. */
  68. #include
  69. #include
  70. #include
  71. #include
  72. #include
  73. #include
  74. #include
  75. #define BUFSZ 256
  76. //建立或获取 ipc 的一组函数的原型说明
  77. int get_ipc_id(char *proc_file,key_t key);
  78. char *set_shm(key_t shm_key,int shm_num,int shm_flag);
  79. int set_msq(key_t msq_key,int msq_flag);
  80. int set_sem(key_t sem_key,int sem_val,int sem_flag);
  81. int down(int sem_id);
  82. int up(int sem_id);
  83. /*信号灯控制用的共同体*/
  84. typedef union semuns {
  85. int val;
  86. } Sem_uns;
  87. /* 消息结构体*/
  88. typedef struct msgbuf {
  89. long mtype;
  90. char mtext[ 1];
  91. } Msg_buf;
  92. //生产消费者共享缓冲区即其有关的变量
  93. key_t buff_key;
  94. int buff_num;
  95. char *buff_ptr;
  96. //生产者放产品位置的共享指针
  97. key_t pput_key;
  98. int pput_num;
  99. int *pput_ptr;
  100. //消费者取产品位置的共享指针
  101. key_t cget_key;
  102. int cget_num;
  103. int *cget_ptr;
  104. //生产者有关的信号量
  105. key_t tobacco_key;
  106. key_t glue_key;
  107. key_t paper_key;
  108. int tobacco_sem;
  109. int glue_sem;
  110. int paper_sem;
  111. //消费者有关的信号量
  112. key_t empty_key;
  113. key_t mutex_key;
  114. int empty_sem;
  115. int mutex_sem;
  116. int sem_val;
  117. int sem_flg;
  118. int shm_flg;

ipc.c


   
   
   
   
  1. /*
  2. 第 41 页实验四、进程同步实验
  3. * Filename
  4. * copyright
  5. * Function
  6. : ipc.c
  7. : (C) 2006 by zhonghonglie
  8. : 一组建立 IPC 机制的函数
  9. */
  10. #include "ipc.h"
  11. /*
  12. * get_ipc_id() 从/proc/sysvipc/文件系统中获取 IPC 的 id 号
  13. * pfile: 对应/proc/sysvipc/目录中的 IPC 文件分别为
  14. *
  15. msg-消息队列,sem-信号量,shm-共享内存
  16. * key: 对应要获取的 IPC 的 id 号的键值
  17. */
  18. int get_ipc_id(char *proc_file,key_t key)
  19. {
  20. FILE *pf;
  21. int i,j;
  22. char line[BUFSZ],colum[BUFSZ];
  23. if((pf = fopen(proc_file, "r")) == NULL){
  24. perror( "Proc file not open");
  25. exit(EXIT_FAILURE);
  26. }
  27. fgets(line, BUFSZ,pf);
  28. while(!feof(pf)){
  29. i = j = 0;
  30. fgets(line, BUFSZ,pf);
  31. while(line[i] == ' ') i++;
  32. while(line[i] != ' ') colum[j++] = line[i++];
  33. colum[j] = '\0';
  34. if(atoi(colum) != key) continue;
  35. j= 0;
  36. while(line[i] == ' ') i++;
  37. while(line[i] != ' ') colum[j++] = line[i++];
  38. colum[j] = '\0';
  39. i = atoi(colum);
  40. fclose(pf);
  41. return i;
  42. }
  43. fclose(pf);
  44. return -1;
  45. }
  46. /*
  47. * 信号灯上的 down/up 操作
  48. * semid:信号灯数组标识符
  49. * semnum:信号灯数组下标
  50. * buf:操作信号灯的结构
  51. */
  52. int down(int sem_id)
  53. {
  54. struct sembuf buf;
  55. buf.sem_op = -1;
  56. buf.sem_num = 0;
  57. buf.sem_flg = SEM_UNDO;
  58. if((semop(sem_id,&buf, 1)) < 0) {
  59. perror( "down error ");
  60. exit(EXIT_FAILURE);
  61. }
  62. return EXIT_SUCCESS;
  63. }
  64. int up(int sem_id)
  65. {
  66. struct sembuf buf;
  67. buf.sem_op = 1;
  68. buf.sem_num = 0;
  69. buf.sem_flg = SEM_UNDO;
  70. if((semop(sem_id,&buf, 1)) < 0) {
  71. perror( "up error ");
  72. exit(EXIT_FAILURE);
  73. }
  74. return EXIT_SUCCESS;
  75. }
  76. /*
  77. * set_sem 函数建立一个具有 n 个信号灯的信号量
  78. *
  79. 如果建立成功,返回 一个信号灯数组的标识符 sem_id
  80. *
  81. 输入参数:
  82. * sem_key 信号灯数组的键值
  83. * sem_val 信号灯数组中信号灯的个数
  84. * sem_flag 信号等数组的存取权限
  85. */
  86. int set_sem(key_t sem_key,int sem_val,int sem_flg)
  87. {
  88. int sem_id;
  89. Sem_uns sem_arg;
  90. //测试由 sem_key 标识的信号灯数组是否已经建立
  91. if((sem_id = get_ipc_id( "/proc/sysvipc/sem",sem_key)) < 0 )
  92. {
  93. //semget 新建一个信号灯,其标号返回到 sem_id
  94. if((sem_id = semget(sem_key, 1,sem_flg)) < 0)
  95. {
  96. perror( "semaphore create error");
  97. exit(EXIT_FAILURE);
  98. }
  99. //设置信号灯的初值
  100. sem_arg.val = sem_val;
  101. if(semctl(sem_id, 0,SETVAL,sem_arg) < 0)
  102. {
  103. perror( "semaphore set error");
  104. exit(EXIT_FAILURE);
  105. }
  106. }
  107. return sem_id;
  108. }
  109. /*
  110. * set_shm 函数建立一个具有 n 个字节 的共享内存区
  111. *
  112. 如果建立成功,返回 一个指向该内存区首地址的指针 shm_buf
  113. *
  114. 输入参数:
  115. * shm_key 共享内存的键值
  116. * shm_val 共享内存字节的长度
  117. * shm_flag 共享内存的存取权限
  118. */
  119. char * set_shm(key_t shm_key,int shm_num,int shm_flg)
  120. {
  121. int i,shm_id;
  122. char * shm_buf;
  123. //测试由 shm_key 标识的共享内存区是否已经建立
  124. if((shm_id = get_ipc_id( "/proc/sysvipc/shm",shm_key)) < 0 )
  125. {
  126. //shmget 新建 一个长度为 shm_num 字节的共享内存,其标号返回到 shm_id
  127. if((shm_id = shmget(shm_key,shm_num,shm_flg)) < 0)
  128. {
  129. perror( "shareMemory set error");
  130. exit(EXIT_FAILURE);
  131. }
  132. //shmat 将由 shm_id 标识的共享内存附加给指针 shm_buf
  133. if((shm_buf = ( char *)shmat(shm_id, 0, 0)) < ( char *) 0)
  134. {
  135. perror( "get shareMemory error");
  136. exit(EXIT_FAILURE);
  137. }
  138. for(i= 0; i0; //初始为 0
  139. }
  140. //shm_key 标识的共享内存区已经建立,将由 shm_id 标识的共享内存附加给指针 shm_buf
  141. if((shm_buf = ( char *)shmat(shm_id, 0, 0)) < ( char *) 0)
  142. {
  143. perror( "get shareMemory error");
  144. exit(EXIT_FAILURE);
  145. }
  146. return shm_buf;
  147. }
  148. /*
  149. * set_msq 函数建立一个消息队列
  150. * 如果建立成功,返回 一个消息队列的标识符 msq_id
  151. * 输入参数:
  152. * msq_key 消息队列的键值
  153. * msq_flag 消息队列的存取权限
  154. */
  155. int set_msq(key_t msq_key,int msq_flg)
  156. {
  157. int msq_id;
  158. //测试由 msq_key 标识的消息队列是否已经建立
  159. if((msq_id = get_ipc_id( "/proc/sysvipc/msg",msq_key)) < 0 )
  160. {
  161. //msgget 新建一个消息队列,其标号返回到 msq_id
  162. if((msq_id = msgget(msq_key,msq_flg)) < 0)
  163. {
  164. perror( "messageQueue set error");
  165. exit(EXIT_FAILURE);
  166. }
  167. }
  168. return msq_id;
  169. }

供应者:


   
   
   
   
  1. /*
  2. * Filename
  3. : producer.c
  4. * copyright
  5. : (C) 2006 by zhonghonglie
  6. * Function
  7. : 建立并模拟生产者进程
  8. */
  9. #include "ipc.h"
  10. int main(int argc,char *argv[])
  11. {
  12. int rate;
  13. //可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度
  14. if(argv[ 1] != NULL) rate = atoi(argv[ 1]);
  15. else rate = 3; //不指定为 3 秒
  16. //共享内存使用的变量
  17. buff_key = 101; //缓冲区任给的键值
  18. buff_num = 1; //缓冲区任给的长度
  19. pput_key = 102; //生产者放产品指针的键值
  20. pput_num = 1; //指针数
  21. shm_flg = IPC_CREAT | 0644; //共享内存读写权限
  22. //获取缓冲区使用的共享内存,buff_ptr 指向缓冲区首地址
  23. buff_ptr = ( char *)set_shm(buff_key,buff_num,shm_flg);
  24. //获取生产者放产品位置指针 pput_ptr
  25. pput_ptr = ( int *)set_shm(pput_key,pput_num,shm_flg);
  26. //信号量使用的变量
  27. tobacco_key = 201; //生产者同步信号灯键值
  28. glue_key = 202; //生产者互斥信号灯键值
  29. paper_key= 203; //生产者3的同步信号灯键值
  30. empty_key = 301; //消费者同步信号灯键值
  31. mutex_key = 302; //消费者互斥信号灯键值
  32. sem_flg = IPC_CREAT | 0644;
  33. //生产者同步信号灯初值设为缓冲区最大可用量
  34. sem_val = buff_num;
  35. //获取生产者同步信号灯,引用标识存 prod_sem
  36. empty_sem = set_sem(empty_key,sem_val,sem_flg);
  37. //消费者初始无产品可取,同步信号灯初值设为 0
  38. sem_val = 0;
  39. //获取消费者同步信号灯,引用标识存 cons_sem
  40. paper_sem = set_sem(paper_key,sem_val,sem_flg);
  41. glue_sem = set_sem(glue_key,sem_val,sem_flg);
  42. tobacco_sem = set_sem(tobacco_key,sem_val,sem_flg);
  43. //生产者互斥信号灯初值为 1
  44. sem_val = 1;
  45. //获取生产者互斥信号灯,引用标识存 pmtx_sem
  46. mutex_sem = set_sem(mutex_key,sem_val,sem_flg);
  47. int i= 0;
  48. //循环执行模拟生产者不断放产品
  49. while( 1){
  50. int d;
  51. //如果缓冲区满则生产者阻塞
  52. down(empty_sem);
  53. //如果另一生产者正在放产品,本生产者阻塞
  54. down(mutex_sem);
  55. //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置
  56. //buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;
  57. sleep(rate);
  58. d=(i++)% 3;
  59. printf( "%d provider put: %d to Buffer[%d]\n",getpid(),d,*pput_ptr);
  60. //存放位置循环下移
  61. *pput_ptr = (*pput_ptr+ 1) % buff_num;
  62. //唤醒阻塞的生产者
  63. up(mutex_sem);
  64. //唤醒阻塞的消费者
  65. if(d== 0)
  66. up(paper_sem);
  67. if(d== 1)
  68. up(glue_sem);
  69. if(d== 2)
  70. up(tobacco_sem);
  71. }
  72. return EXIT_SUCCESS;
  73. }
  74. } /*
  75. * Filename
  76. : producer.c
  77. * copyright
  78. : (C) 2006 by zhonghonglie
  79. * Function
  80. : 建立并模拟生产者进程
  81. */
  82. #include "ipc.h"
  83. int main(int argc,char *argv[])
  84. {
  85. int rate;
  86. //可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度
  87. if(argv[ 1] != NULL) rate = atoi(argv[ 1]);
  88. else rate = 3; //不指定为 3 秒
  89. //共享内存使用的变量
  90. buff_key = 101; //缓冲区任给的键值
  91. buff_num = 1; //缓冲区任给的长度
  92. pput_key = 102; //生产者放产品指针的键值
  93. pput_num = 1; //指针数
  94. shm_flg = IPC_CREAT | 0644; //共享内存读写权限
  95. //获取缓冲区使用的共享内存,buff_ptr 指向缓冲区首地址
  96. buff_ptr = ( char *)set_shm(buff_key,buff_num,shm_flg);
  97. //获取生产者放产品位置指针 pput_ptr
  98. pput_ptr = ( int *)set_shm(pput_key,pput_num,shm_flg);
  99. //信号量使用的变量
  100. tobacco_key = 201; //生产者同步信号灯键值
  101. glue_key = 202; //生产者互斥信号灯键值
  102. paper_key= 203; //生产者3的同步信号灯键值
  103. empty_key = 301; //消费者同步信号灯键值
  104. mutex_key = 302; //消费者互斥信号灯键值
  105. sem_flg = IPC_CREAT | 0644;
  106. //生产者同步信号灯初值设为缓冲区最大可用量
  107. sem_val = buff_num;
  108. //获取生产者同步信号灯,引用标识存 prod_sem
  109. empty_sem = set_sem(empty_key,sem_val,sem_flg);
  110. //消费者初始无产品可取,同步信号灯初值设为 0
  111. sem_val = 0;
  112. //获取消费者同步信号灯,引用标识存 cons_sem
  113. paper_sem = set_sem(paper_key,sem_val,sem_flg);
  114. glue_sem = set_sem(glue_key,sem_val,sem_flg);
  115. tobacco_sem = set_sem(tobacco_key,sem_val,sem_flg);
  116. //生产者互斥信号灯初值为 1
  117. sem_val = 1;
  118. //获取生产者互斥信号灯,引用标识存 pmtx_sem
  119. mutex_sem = set_sem(mutex_key,sem_val,sem_flg);
  120. int i= 0;
  121. //循环执行模拟生产者不断放产品
  122. while( 1){
  123. int d;
  124. //如果缓冲区满则生产者阻塞
  125. down(empty_sem);
  126. //如果另一生产者正在放产品,本生产者阻塞
  127. down(mutex_sem);
  128. //用写一字符的形式模拟生产者放产品,报告本进程号和放入的字符及存放的位置
  129. //buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;
  130. sleep(rate);
  131. d=(i++)% 3;
  132. printf( "%d provider put: %d to Buffer[%d]\n",getpid(),d,*pput_ptr);
  133. //存放位置循环下移
  134. *pput_ptr = (*pput_ptr+ 1) % buff_num;
  135. //唤醒阻塞的生产者
  136. up(mutex_sem);
  137. //唤醒阻塞的消费者
  138. if(d== 0)
  139. up(paper_sem);
  140. if(d== 1)
  141. up(glue_sem);
  142. if(d== 2)
  143. up(tobacco_sem);
  144. }
  145. return EXIT_SUCCESS;
  146. }
  147. }

 

三个抽烟者:

glue.c:


   
   
   
   
  1. /*
  2. Filename
  3. : consumer.c
  4. copyright
  5. : (C) by zhanghonglie
  6. Function
  7. : 建立并模拟消费者进程
  8. */
  9. #include "ipc.h"
  10. int main(int argc,char *argv[])
  11. {
  12. int rate;
  13. //可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度
  14. if(argv[ 1] != NULL) rate = atoi(argv[ 1]);
  15. else rate = 3; //不指定为 3 秒
  16. //共享内存 使用的变量
  17. buff_key = 101; //缓冲区任给的键值
  18. buff_num = 1; //缓冲区任给的长度
  19. cget_key = 103; //消费者取产品指针的键值
  20. cget_num = 1; //指针数
  21. shm_flg = IPC_CREAT | 0644; //共享内存读写权限
  22. //获取缓冲区使用的共享内存,buff_ptr 指向缓冲区首地址
  23. buff_ptr = ( char *)set_shm(buff_key,buff_num,shm_flg);
  24. //获取消费者取产品指针,cget_ptr 指向索引地址
  25. cget_ptr = ( int *)set_shm(cget_key,cget_num,shm_flg);
  26. //信号量使用的变量
  27. tobacco_key = 201; //生产者同步信号灯键值
  28. glue_key = 202; //生产者互斥信号灯键值
  29. paper_key= 203//生产者3的同步信号灯键值
  30. empty_key = 301; //消费者同步信号灯键值
  31. mutex_key = 302; //消费者互斥信号灯键值
  32. sem_flg = IPC_CREAT | 0644; //信号灯操作权限
  33. //生产者同步信号灯初值设为缓冲区最大可用量
  34. sem_val = buff_num;
  35. //获取生产者同步信号灯,引用标识存 prod_sem
  36. empty_sem = set_sem(empty_key,sem_val,sem_flg);
  37. //消费者初始无产品可取,同步信号灯初值设为 0
  38. sem_val = 0;
  39. //获取消费者同步信号灯,引用标识存 cons_sem
  40. glue_sem = set_sem(glue_key,sem_val,sem_flg);
  41. while( 1){
  42. //如果无产品消费者阻塞
  43. down(glue_sem);
  44. //用读一字符的形式模拟消费者取产品,报告本进程号和
  45. sleep(rate);
  46. printf( "%d  1号吸烟者 得到了: 烟草和纸 from Buffer[%d]\n",getpid(),*cget_ptr);
  47. //读取位置循环下移
  48. *cget_ptr = (*cget_ptr+ 1) % buff_num;
  49. //唤醒阻塞的生产者
  50. up(empty_sem);
  51. }
  52. return EXIT_SUCCESS;
  53. }

 

 

 

tobacco.c:

 


   
   
   
   
  1. /*
  2. Filename
  3. : consumer.c
  4. copyright
  5. : (C) by zhanghonglie
  6. Function
  7. : 建立并模拟消费者进程
  8. */
  9. #include "ipc.h"
  10. int main(int argc,char *argv[])
  11. {
  12. int rate;
  13. //可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度
  14. if(argv[ 1] != NULL) rate = atoi(argv[ 1]);
  15. else rate = 3; //不指定为 3 秒
  16. //共享内存 使用的变量
  17. buff_key = 101; //缓冲区任给的键值
  18. buff_num = 1; //缓冲区任给的长度
  19. cget_key = 103; //消费者取产品指针的键值
  20. cget_num = 1; //指针数
  21. shm_flg = IPC_CREAT | 0644; //共享内存读写权限
  22. //获取缓冲区使用的共享内存,buff_ptr 指向缓冲区首地址
  23. buff_ptr = ( char *)set_shm(buff_key,buff_num,shm_flg);
  24. //获取消费者取产品指针,cget_ptr 指向索引地址
  25. cget_ptr = ( int *)set_shm(cget_key,cget_num,shm_flg);
  26. //信号量使用的变量
  27. tobacco_key = 201; //生产者同步信号灯键值
  28. glue_key = 202; //生产者互斥信号灯键值
  29. paper_key= 203; //生产者3的同步信号灯键值
  30. empty_key = 301; //消费者同步信号灯键值
  31. mutex_key = 302; //消费者互斥信号灯键值
  32. sem_flg = IPC_CREAT | 0644; //信号灯操作权限
  33. //生产者同步信号灯初值设为缓冲区最大可用量
  34. sem_val = buff_num;
  35. //获取生产者同步信号灯,引用标识存 prod_sem
  36. empty_sem = set_sem(empty_key,sem_val,sem_flg);
  37. //消费者初始无产品可取,同步信号灯初值设为 0
  38. sem_val = 0;
  39. //获取消费者同步信号灯,引用标识存 cons_sem
  40. tobacco_sem = set_sem(tobacco_key,sem_val,sem_flg);
  41. while( 1){
  42. //如果无产品消费者阻塞
  43. down(tobacco_sem);
  44. //用读一字符的形式模拟消费者取产品,报告本进程号和
  45. sleep(rate);
  46. printf( "%d 2号吸烟者 得到了: 胶水和纸 from Buffer[%d]\n",getpid(),*cget_ptr);
  47. //读取位置循环下移
  48. *cget_ptr = (*cget_ptr+ 1) % buff_num;
  49. //唤醒阻塞的生产者
  50. up(empty_sem);
  51. }
  52. return EXIT_SUCCESS;
  53. }

 

 

 

 

 

paper.c:

 


   
   
   
   
  1. /*
  2. Filename
  3. : consumer.c
  4. copyright
  5. : (C) by zhanghonglie
  6. Function
  7. : 建立并模拟消费者进程
  8. */
  9. #include "ipc.h"
  10. int main(int argc,char *argv[])
  11. {
  12. int rate;
  13. //可在在命令行第一参数指定一个进程睡眠秒数,以调解进程执行速度
  14. if(argv[ 1] != NULL) rate = atoi(argv[ 1]);
  15. else rate = 3; //不指定为 3 秒
  16. //共享内存 使用的变量
  17. buff_key = 101; //缓冲区任给的键值
  18. buff_num = 1; //缓冲区任给的长度
  19. cget_key = 103; //消费者取产品指针的键值
  20. cget_num = 1; //指针数
  21. shm_flg = IPC_CREAT | 0644; //共享内存读写权限
  22. //获取缓冲区使用的共享内存,buff_ptr 指向缓冲区首地址
  23. buff_ptr = ( char *)set_shm(buff_key,buff_num,shm_flg);
  24. //获取消费者取产品指针,cget_ptr 指向索引地址
  25. cget_ptr = ( int *)set_shm(cget_key,cget_num,shm_flg);
  26. //信号量使用的变量
  27. tobacco_key = 201; //生产者同步信号灯键值
  28. glue_key = 202; //生产者互斥信号灯键值
  29. paper_key= 203; //生产者3的同步信号灯键值
  30. empty_key = 301; //消费者同步信号灯键值
  31. mutex_key = 302; //消费者互斥信号灯键值
  32. sem_flg = IPC_CREAT | 0644; //信号灯操作权限
  33. //生产者同步信号灯初值设为缓冲区最大可用量
  34. sem_val = buff_num;
  35. //获取生产者同步信号灯,引用标识存 prod_sem
  36. empty_sem = set_sem(empty_key,sem_val,sem_flg);
  37. //消费者初始无产品可取,同步信号灯初值设为 0
  38. sem_val = 0;
  39. //获取消费者同步信号灯,引用标识存 cons_sem
  40. paper_sem = set_sem(paper_key,sem_val,sem_flg);
  41. while( 1){
  42. //如果无产品消费者阻塞
  43. down(paper_sem);
  44. //用读一字符的形式模拟消费者取产品,报告本进程号和
  45. sleep(rate);
  46. printf( "%d 0号吸烟者 得到了: 烟草和胶水 from Buffer[%d]\n",getpid(),*cget_ptr);
  47. //读取位置循环下移
  48. *cget_ptr = (*cget_ptr+ 1) % buff_num;
  49. //唤醒阻塞的生产者
  50. up(empty_sem);
  51. }
  52. return EXIT_SUCCESS;
  53. }

 

 

makefile:


   
   
   
   
  1. hdrs = ipc.h
  2. opts = -g -c
  3. c_src = glue.c ipc.c
  4. c_obj = glue.o ipc.o
  5. d_src = paper.c ipc.c
  6. d_obj = paper.o ipc.o
  7. e_src = tobacco.c ipc.c
  8. e_obj = tobacco.o ipc.o
  9. f_src = provider.c ipc.c
  10. f_obj = provider.o ipc.o
  11. all: glue paper tobacco provider
  12. glue: $(c_obj)
  13. gcc $(c_obj) -o glue
  14. glue.o: $(c_src) $(hdrs)
  15. gcc $(opts) $(c_src)
  16. paper: $(d_obj)
  17. gcc $(d_obj) -o paper
  18. paper.o: $(p_src) $(hdrs)
  19. gcc $(opts) $(d_src)
  20. tobacco: $(e_obj)
  21. gcc $(e_obj) -o tobacco
  22. tobacco.o: $(e_src) $(hdrs)
  23. gcc $(opts) $(e_src)
  24. provider: $(f_obj)
  25. gcc $(f_obj) -o provider
  26. provider.o: $(f_src) $(hdrs)
  27. gcc $(opts) $(f_src)
  28. clean:
  29. rm glue provider paper tobaco *.o

 


(原文地址 https://blog.csdn.net/qq_38247544/article/details/80489106)

你可能感兴趣的:(数据结构)