Os-作业四:进程

作业四:进程

20373915-朱文涛


读者写者问题(写者优先)

题目:满足以下条件的读者写者问题:

  • 读者可以共享;

  • 读写互斥、写写互斥;

  • 写者优先于读者(一旦有写者,则后续读者必须等待,唤醒时优先考虑写者)

答:如下述伪代码所示,重要部分注释:

semaphore mutex_for_reader_count = 1; //用于写reader_count互斥
semaphore mutex_for_writer_count = 1; //用于写writer_count互斥
int reader_count = 0;
int writer_count = 0;
semaphore mutex = 1; //*************** 共享文件锁 **************
semaphore mutex_for_write = 1; //用于实现同时最多一个写者写
semaphore mutex_for_read = 1; //用于实现读者正真的优先

Reader() {
while(1) {
    P(mutex_for_read);//
    P(mutex);//没有写者在写时可以进行读
    P(mutex_for_reader_count); //互斥访问reader_count变量
    if (reader_count == 0) { //如果是第一个读进程访问共享变量
        P(mutex_for_write); //阻止写进程写
      }
    reader_count++;
    V(mutex_for_reader_count); //释放互斥变量reader_count
    V(mutex); //恢复对共享文件的访问(可以多读者共享)
    V(mutex_for_read);
     
    -----------------------------------
       read_something();
    -----------------------------------
         
       P(mutex_for_reader_count); //读完读者离开
    reader_count--;
    if (reader_count == 0) {
        V(mutex_for_write); //如果已经无读者,释放写进程锁,使写进程可写
      }
    V(mutex_for_reader_count);
  }
}

/*
分析写者优先:
1:对于写者,如果拿到了mutex锁,则不允许其他读文件读,同时mutex_for_write保证最多一个写着写
2:假定写者写操作时,来了若干读者,最后来了写者,由于write_count++,故写进程不会释放mutex锁,达到类似于 优先唤醒写进程的工作,此时写进程阻塞在mutex_for_write队列中,等到当前写进程写完,便可优先写
3:例如一个读者释放mutex锁,此时多读者进程和写进程争抢mutex锁,加入mutex_for_read锁,使其余读者在 mutex_for_read前阻塞排队,防止被阻塞的一些读进程排在写进程前面。
*/
Writer() {
P(mutex_for_writer_count);//互斥访问reader_count变量
if (writer_count == 0) { //如果是第一个写进程写共享文件
    P(mutex); //阻止读操作
  }
writer_count++;
V(mutex_for_writer_count);
 
P(mutex_for_write); //阻止写操作
-----------------------------------
   write_something();
   -----------------------------------
   V(mutex_for_write);
 
P(mutex_for_writer_count); //写完写者离开
writer_count--;
if (writer_count == 0) {
    V(mutex); //如果无写者,恢复共享文件
  }
V(mutex_for_writer_count);
}

 

寿司店问题

题目:假设一个寿司店有5个座位,如果顾客到达的时候有一个空座位,顾客可以立刻就坐。但是如果顾客到达的时候5个座位都是满的有人已经就坐,这就意味着这些人都是一起来吃饭的,那么顾客需要等待所有的人一起离开才能就坐。编写同步原语,实现这个场景的约束。

答:如下述伪代码所示,重要部分注释:

semaphore mutex = 1; //锁,互斥对各变量的修改*
semaphore VIP_ROME = 0;
int number_eating = 0;
int number_waiting = 0;
bool need_wait = false

//来到饭店,判断等待情况
P(mutex);
if need_wait: //需要等待所有人离开
number_waiting ++;
V(mutex);
P(VIP_ROOM); //在贵宾室等待
else: //可以直接吃,如果就坐后满了,后续需要等待
number_eating ++;
need_wait = (eating == 5);
V(mutex);

//开始大快朵颐    
eating_AoLiGei();

//吃完跑路
P(mutex);
number_eating --; //吃完了
if number_eating == 0: //如果最后一个顾客,可唤醒VIP_ROOM上等待的顾客
number_can_eating = min(5, waiting); //最多5个顾客可以吃
number_waiting -= number_can_eating;
number_eating += number_can_eating;
need_wait = (number_eating == 5);
for (int i = 0; i < number_can_eating; i++) {
V(VIP_ROOM); //叫等待的人来进餐
}
V(mutex);

 

生产者-消费者模型

题目:三个进程 P1、P2、P3 互斥使用一个包含 N(N>0)个单元的缓冲区。P1 每次用 produce()生成一个正整数并用 put()送入缓冲区某一个空单元中;P2 每次用 getodd()从该缓冲区中取出一个奇数并用 countodd()统计奇数个数;P3 每次用 geteven()从该缓冲区中取出一个偶数并用 counteven()统计偶数个数。请用信号量机制实现这三个进程的同步与互斥活动,并说明所定义的信号量的含义。要求用伪代码描述。

答:如下述伪代码所示,重要部分注释:

semaphore mutex = 1;//互斥信号量
semaphore even = 0;//缓冲区偶数个数
semaphore odd = 0//缓冲区奇数个数
semaphore empty = n;//缓冲区空闲个数
// @invariant empty + odd + even = n;
Producer() {
while(1) {
    num = produce_an_interger(); //生产一个数据
    P(empty); //当buffer有空可以放入数据
    P(mutex); //进入临界区
    add_num_to_buffer(); //加入生产元素入buffer
    if (num % 2 == 0) { //根据生产元素决定唤醒哪个进程
        V(even);
      } else {
        V(odd);
      }
    V(mutex); //释放资源
  }
}

P1() {
while(1) {
    P(odd); //接到Produce通知后唤醒P1
    P(mutex); //进入临界区
    getodd(); //从buffer中获取奇数
    V(mutex); //离开临界区
    V(empty); //缓冲区元素个数减一
    countodd(); //消费数据
  }
}

P2() {
while(1) {
    P(oven); //接到Produce通知后唤醒P2
    P(mutex); //进入临界区
    getoven(); //从buffer中获取偶数
    V(mutex); //离开临界区
    V(empty); //缓冲区元素个数减一
    countoven(); //消费数据
  }
}

 

搜索-插入-删除问题

问题:三个线程对一个单链表进行并发的访问,分别进行搜索、插入和删除。搜索线程仅仅读取链表,因此多个搜索线程可以并发。插入线程把数据项插入到链表最后的位置;多个插入线程必须互斥防止同时执行插入操作。但是,一个插入线程可以和多个搜索线程并发执行。最后,删除线程可以从链表中任何一个位置删除数据。一次只能有一个删除线程执行;删除线程之间,删除线程和搜索线程,删除线程和插入线程都不能同时执行。请编写三类线程的同步互斥代码,描述这种三路的分类互斥问题。

答:如下述伪代码所示,重要部分注释:

semaphore mutex_for_serach_number = 1; //查找数量互斥信号量
semaphore mutex_for_insert_number = 1; //插入数量互斥信号量
int serach_number = 0;
int insert_number = 0;
semaphore mutex_for_insert = 1; //多插入操作互斥
semaphora mutex_for_no_serach = 1; //无查询操作
semaphora mutex_for_no_insert = 1; //无插入操作
 
Inserter() {
P(mutex_for_insert_number);
if (number_insert == 0) {
    P(mutex_for_no_insert);
  }
number_insert ++;
V(mutex_for_no_insert);
 
P(mutex_for_insert);//只允许同时有一个插入操作
insert_element();
V(mutex_for_insert);
 
P(mutex_for_insert_number);
number_insert --;
if (number_insert == 0) {
    V(mutex_for_no_insert);
  }
V(mutex_for_no_insert);
}

Seracher() {
P(mutex_for_serach_number);
if (number_serach == 0) {
    P(mutex_for_no_serach);
  }
number_serach ++;
V(mutex_for_serach_number);
 
serach_for_element();
 
P(mutex_for_serach_number);
 number_serach --;
if (number_serach == 0) {
    V(mutex_for_no_serach);
  }
V(mutex_for_serach_number);
}

Deletor() {
P(mutex_for_no_insert); //同时拿到无插入和查找通知
P(mutex_for_no_serach);
 
delete_element();

V(mutex_for_no_insert);
V(mutex_for_no_serach);
}


posted @ 2022-07-06 22:38  `Demon  阅读(40)  评论(0编辑  收藏  举报