DDD操作系统实验（六）

实验目的

• 理解进程同步与进程互斥的概念。
• 学会使用peterson算法、PV信号量方法解决进程同步与互斥问题。

实验内容

第一步：我们假设一种最简单producer-consumer的情况：
当前系统中有两个进程在并发执行，它们分别是producer与consumer。其中，producer与consumer共享变量counter，它们分别对counter进行了修改。附件simple_producer_consumer_peterson.c给出了这样的一种情形。

• A. 运行该程序会出现什么后果？
• B. 请使用peterson算法解决该问题。
• C. 你的系统是如何调度peterson算法的？这个结果是否符合预期？

第二步：其实，我们可以使用更简单的系统调用来完成上述互斥问题。
只要定义一个互斥量mutex，然后使用系统的线程锁就可以完成上述事情。
可以参考下面的做法:

• pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
• pthread_mutex_lock(&mutex);
• pthread_mutex_unlock(&mutex);

现在你可以试着将上面的peterson算法换成线程锁。

第三步：现在，我们来尝试更复杂的producer-consumer的情况
当前系统中有P_NUM+C_NUM个进程在并发执行，它们分别是P_NUM个producer与C_NUM个consumer。其中，producer与consumer共享一个buffer，buffer的深度是BUF_SIZE。我们要求：一次只能有一个进程访问buffer，buffer满时不可以写，buffer空时不可以读。

现在，你可以思考下用信号量如何解决上述问题，然后参考我们的附件代码“complicated_producer_consumer.c”，观察参考代码是如何利用信号量解决问题。本部分需要你观察、运行所给的代码，掌握如何使用信号量解决进程同步问题。这个代码尽管能够实现所述功能，但也有点问题，欢迎同学们指出并完善它。

第四步：请将你的学号最后1位数字数模5，得到的结果对应接下来你需要解决的问题的序号，要根据PPT要求的输入输出来完成。如果对应的问题在PPT中没有要求，则需要自定义输入输出格式，保证整洁简单。可以在应做题目之外选择多做一题，有加分。

1. 读者-写者问题，读者优先（PPT中有格式定义要求）
2. 读者-写者问题，公平竞争（PPT中有格式定义要求）
3. 读者-写者问题，写者优先（PPT中有格式定义要求）
4. 哲学家进餐问题（需要用两种方法完成）
5. 理发师问题

实验结果

第一步

1. 原代码运行结果及分析
   

2. 你的运行结果及分析

int counter;
int turn=0;
int flag[2];
void *producer(void *param){
        flag[0] = 1;
        turn = 1;
        while(flag[1] && turn==1);
        int i;
        int a;
        for (i=0;i<10;i++){
                a=counter;
                sleep_rand_time();//or sleep(1);
                counter=a+1;
                printf("producer %d\n",counter);
        }
        printf("producer end\n");
        flag[0]=0;
        pthread_exit(0);
}
void *consumer(void *param){
        flag[1] = 1;
        turn=0;
        while(flag[0] && turn==0);
        int j;
        int b;
        for (j=0;j<10;j++){
                b=counter;
                sleep_rand_time(); //or sleep(1);
                counter=b-1;
                printf("consumer %d\n",counter);
        }
        printf("consumer end\n");
        flag[1]=0;
        pthread_exit(0);
}

producer和consumer并发执行，用flag[]数组和turn标记，系统先调用consumer，并且在其结束之前一直是先让consumer执行，导致了producer一直在执行while循环无法进入临界区.

第二步：

1. 使用Peterson算法如何解决问题，运行结果及分析
   

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *producer(void *param){
        pthread_mutex_lock(&mutex);
        int i;
        int a=0;
        for (i=0;i<10;i++){
                a=counter;
                sleep_rand_time();//or sleep(1);
                counter=a+1;
                printf("producer %d\n",counter);
        }
        printf("producer end\n");
        pthread_mutex_unlock(&mutex);
        pthread_exit(0);
}
void *consumer(void *param){
        pthread_mutex_lock(&mutex);
        int j;
        int b=10;
        for (j=0;j<10;j++){
                b=counter;
                sleep_rand_time(); //or sleep(1);
                counter=b-1;
                printf("consumer %d\n",counter);
        }
        printf("consumer end\n");
        pthread_mutex_unlock(&mutex);
        pthread_exit(0);
}

用线程锁替换turn和flag，pthread_mutex_t创建一个互斥锁，再用pthread_mutex_lock(&mutex);和pthread_mutex_unlock(&mutex);分别在producer和consumer中的临界区前后添加

2. 使用信号量如何解决问题，运行结果及分析

#include <semaphore.h>
sem_t sem;
void *producer(void *param){
        sem_wait(&sem);
        int i;
        int a=0;
        for (i=0;i<10;i++){
                a=counter;
                sleep_rand_time();//or sleep(1);
                counter=a+1;
                printf("producer %d\n",counter);
        }
        printf("producer end\n");
        sem_post(&sem);
        pthread_exit(0);
}
void *consumer(void *param){
        sem_wait(&sem);
        int j;
        int b=10;
        for (j=0;j<10;j++){
                b=counter;
                sleep_rand_time(); //or sleep(1);
                counter=b-1;
                printf("consumer %d\n",counter);
        }
        printf("consumer end\n");
        sem_post(&sem);
        pthread_exit(0);
}
int main(int argc, char *argv[]){
        sem_init(&sem,0,1);

定义信号量sem，主函数初始化信号量sem_init，分别在producer和consumer中的临界区前后添加sem_wait()和sem_post()替代线程锁。

第三步：

1. 运行所给代码结果及分析
   Main函数创建5个producer线程和5个comsumer线程，在这两个线程中使用pv信号量确保buf_size保持正常，使用线程锁保证有且仅有一个进程能访问buffer，程序需要手动退出。
   

第四步：

1. 请描述你是如何解决该问题的（解决策略详述）？
   读者优先指的是除非有写者在写文件，否则读者不需要等待。所以可以用一个整型变量read_count记录当前的读者数目，用于确定是否需要释放正在等待的写者线程(当read_count=0时，表明所有的读者读完，需要释放写者等待队列中的一个写者)。每一个读者开始读文件时，必须修改read_count变量。因此需要一个互斥对象mutex来实现对全局变量read_count修改时的互斥。
   为了实现写-写互斥，需要增加一个临界区对象write。当写者发出写请求时，必须申请临界区对象的所有权。通过这种方法，也可以实现读-写互斥，当read_count=1时(即第一个读者到来时)，读者线程也必须申请临界区对象的所有权。
2. 得到了怎样的结果？这个结果与预期相符吗？为什么？
   测试数据：
   1 R 1 3
   2 W 2 7
   3 R 3 2
   4 W 5 5
   5 W 5 13

结果：

当读者拥有临界区的所有权时，写者阻塞在临界区对象write上。当写者拥有临界区的所有权时，第一个读者判断完“read_count==1”后阻塞在write上，其余的读者由于等待对read_count的判断，阻塞在mutex上。