• 姓名：肖斯凯
• 学号：201821121015
• 班级：计算1811

1. 选择哪一个问题

选题哪个问题？

• 生产者-消费者问题

2. 给出伪代码

主线程创建一个辅助线程 ，主线程使用选择排序算法对数组的前半部分排序 ， 辅助线程使用选择排序算法对数组的后半部分排序， 主线程等待辅助线程运行結束后,使用归并排序算法归并数组的前半部分和后半部分

3. 给出完整代码

  1 #include<stdio.h>
  2 #include<pthread.h>
  3 #include<unistd.h>
  4 
  5 #define CAPACITY 4
  6 
  7 char buffer1[4];
  8 char buffer2[4];
  9 
 10 int crea; //生产者 
 11 int comp1;//计算者 
 12 int comp2;//计算者 
 13 int cons; //消费者 
 14 
 15 
 16 int buffer1_is_empty(){
 17     return crea==comp1;
 18 }
 19 
 20 int buffer1_is_full(){
 21     return (crea+1)%CAPACITY==comp1;
 22 }
 23 
 24 int buffer2_is_empty(){
 25     return comp2==cons;
 26 }
 27 
 28 int buffer2_is_full(){
 29     return (cons+1)%CAPACITY==comp2;
 30 }
 31 
 32 int get_item1(){
 33     int item;
 34 
 35     item=buffer1[comp1];
 36     comp1=(comp1+1)%CAPACITY;
 37     return item;
 38 }
 39 
 40 int get_item2(){
 41     int item;
 42 
 43     item=buffer2[cons];
 44     cons=(cons+1)%CAPACITY;
 45     return item;
 46 }
 47 
 48 int put_item1(int item){
 49         buffer1[crea]=item;
 50         crea=(crea+1)%CAPACITY;
 51 }
 52 
 53 int put_item2(int item){
 54         buffer2[comp2]=item;
 55         comp2=(comp2+1)%CAPACITY;
 56 }
 57 
 58 typedef struct{
 59         int value;
 60         pthread_mutex_t mutex;
 61         pthread_cond_t  cond;
 62 }sema_t;
 63 
 64 void sema_init(sema_t *sema,int value){
 65         sema->value=value;
 66         pthread_mutex_init(&sema->mutex,NULL);
 67         pthread_cond_init(&sema->cond,NULL);
 68 }
 69 
 70 void sema_wait(sema_t *sema){
 71         pthread_mutex_lock(&sema->mutex);
 72         sema->value--;
 73         while(sema->value<0)
 74                 pthread_cond_wait(&sema->cond,&sema->mutex);
 75         pthread_mutex_unlock(&sema->mutex);
 76 }
 77 
 78 void sema_signal(sema_t *sema){
 79         pthread_mutex_lock(&sema->mutex);
 80         ++sema->value;
 81         pthread_cond_signal(&sema->cond);
 82         pthread_mutex_unlock(&sema->mutex);
 83 }
 84 
 85 sema_t mutex_sema1;
 86 sema_t empty_buffer1_sema;
 87 sema_t full_buffer1_sema;
 88 
 89 sema_t mutex_sema2;
 90 sema_t empty_buffer2_sema;
 91 sema_t full_buffer2_sema;
 92 
 93 #define ITEM_COUNT  (CAPACITY *2)
 94 
 95 void *consumer(void *arg){
 96     int i;
 97     int item;
 98 
 99     for(i=0;i<ITEM_COUNT;i++){
100             sema_wait(&full_buffer2_sema);
101             sema_wait(&mutex_sema2);
102 
103             item=get_item2();
104 
105             sema_signal(&mutex_sema2);
106             sema_signal(&empty_buffer2_sema);
107             printf("                   consume item:%c\n",item);
108     }
109     return NULL;
110 }
111 
112 void *computer(void *arg){
113     int i;
114     int item;
115 
116     for(i=0;i<ITEM_COUNT;i++){
117             sema_wait(&full_buffer1_sema);
118             sema_wait(&mutex_sema1);
119 
120             item=get_item1();
121 
122             sema_signal(&mutex_sema1);
123             sema_signal(&empty_buffer1_sema);
124             printf("        computer get item:%c\n",item);
125 
126             sema_wait(&empty_buffer2_sema);
127             sema_wait(&mutex_sema2);
128 
129             item-=32;
130             put_item2(item);
131             printf("        computer put item:%c\n",item);
132 
133             sema_signal(&mutex_sema2);
134             sema_signal(&full_buffer2_sema);
135     }
136     return NULL;
137 }
138 
139 void create(){
140         int i;
141         int item;
142 
143         for(i=0;i<ITEM_COUNT;i++){
144             sema_wait(&empty_buffer1_sema);
145             sema_wait(&mutex_sema1);
146 
147             item=i+'a';
148             put_item1(item);
149             printf("create item:%c\n",item);
150 
151             sema_signal(&mutex_sema1);
152             sema_signal(&full_buffer1_sema);
153         }
154 }
155 
156 int main(){
157         pthread_t computer_tid;
158         pthread_t consumer_tid;
159 
160         sema_init(&mutex_sema1,1);
161         sema_init(&empty_buffer1_sema,CAPACITY-1);
162         sema_init(&full_buffer1_sema,0);
163 
164         sema_init(&mutex_sema2,1);
165         sema_init(&empty_buffer2_sema,CAPACITY-1);
166         sema_init(&full_buffer2_sema,0);
167 
168         pthread_create(&consumer_tid,NULL,consumer,NULL);
169         pthread_create(&computer_tid,NULL,computer,NULL);
170         create();
171 
172         pthread_join(consumer_tid,NULL);
173         pthread_join(computer_tid,NULL);
174         return 0;
175 }

4. 运行结果并解释

标签：CAPACITY,item,号量,sema,int,互所,pthread,mutex,实验报告
来源： https://www.cnblogs.com/sk-x/p/12994256.html