操作系统期末复习

Operation-System Structures

Operation System services（5分）

syscalls

from User to Kerner Model（5分）

中断：用户态变为内核态

Process

Process State(5分)

Process scheduling(15分)

需要画甘特图

FCFS √

先来先服务

• 优点：公平
• 缺点：对长作业有利，对短作业不利
• 非抢占式
• 不会导致饥饿

SJF √

最短的作业优先得到服务，非抢占式

• 优点：最短的平均等待时间，周转时间
• 缺点：不公平
• 对短作业有利，对长作业不利，可能产生饥饿现象

优先级调度算法 √

• 非抢占式

• 抢占式

• 可能产生饥饿

SRTN

最短的作业优先得到服务，抢占式

• 优点：最短的平均等待时间，周转时间
• 缺点：不公平
• 对短作业有利，对长作业不利，可能产生饥饿现象

高响应比优先（HRRN）

• 非抢占式
• FCFS和SJF的综合

时间片轮转(RR)

• 抢占式
• 不会产生饥饿

Process Synchronization(20分)

操作系统 | PV操作七大经典问题 生产者消费者 读者写者 哲学家进餐 理发师理发睡觉 和尚打水 吸烟者 吃水果_操作系统生产者消费者解决的问题-CSDN博客

生产者消费者问题（15分）

基础

多生产者多消费者问题

吸烟家问题

理发师睡觉理发

有一个理发师，一把理发椅和 N 把供等候理发的顾客坐的椅子。
如果没有顾客，则理发师便在理发师椅子上睡觉；
当一个顾客到来时，必须唤醒理发师进行理发；
如果理发师正在理发时又有顾客来到，则如果有空椅子可坐，他就坐下来等，如果没有空椅子，他就离开。

int wait = 0; //顾客等待的数量
semaphore mutex = 1; //互斥访问 wait
semaphore barber = 0; //理发师信号量
semaphore customer = 0; //顾客的信号量
//理发师
void barber() {
	while (true) {
		P(customer); //等待顾客来理发
		P(mutex); //申请互斥访问wait
		wait = wait - 1; // 等待人数减少一人
		V(mutex);//释放临界资源
		V(barber);//让理发师去理发
		进行理发;
	}
}
//顾客
void customer () {
	while (true) {
		P(mutex);//申请互斥访问wait
		if (wait < 10) { //代表10把椅子没有坐满 还可以坐人
			wait = wait + 1 ;
			V(mutex);
			V(customer );
			P(barber);//等待理发师来理发
			去理发;
		} else {
			//人满了 顾客直接离开
			V(mutex);
		}
	}
}

题目

三个进程p1,p2,p3互斥的使用一个包含n个单元的缓冲区，p1每次用producer()生成一个正整数，并用put()送入到缓冲区的某个单元中；p2每次用getodd()从缓冲区取出一个奇数，并用countodd()计算奇数的个数；p3每次用geteven()从缓冲区取出一个偶数，并用counteven()统计偶数的个数。
/注：题中给出的函数，均是封装好的，不需要在单独用p，v操作实现/

Semaphore mutex=1;//互斥信号量保护临界资源
Semaphore empty=n;//初始化时有n个单元
Semaphore odd=0; //装奇数的缓冲区个数
Semaphore even=0;//装偶数的缓冲区个数

/*进程p1,即生产者*/
p1(){
 while(1){
  number=producer();//产生一个数
  p(empty);//接收到放数的消息
  p(mutex);//将数放入缓冲区
  put();
  v(mutex);
  if(number%2==0)
  V(even);//通知偶数接收者取数
  else
  V(odd);//通知奇数接收者取数
 }
}

/*进程p2,即消费者一，即奇数接收者*/
P2(){
 while(1){
  p(odd);
  p(mutex);//取奇数
  getodd();
  v(mutex);
  v(empty);//通知生产者可以放数了。
  countOdd();
 }
}

/*进程p3，即消费者二，即偶数接收者*/
p3(){
 while(1){
  p(even);//接收到取偶数的消息
  p(mutex);//取偶数
  geteven();
  v(mutex);
  v(empty);
  counteven();
 }
}

读者写者问题（5分）

1. 读进程优先

2. 写进程优先

哲学家问题

1. 最多允许有四位哲学家同时去拿左边的筷子，然后再拿右边的筷子，最终保证至少有一位哲学家能够进餐，并在就餐完毕时同时释放他用过的两只筷子，从而使更多的哲学家能够进餐。

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量
semaphore count = 4;	//控制最多允许四位哲学家同时进餐

void philosopher(int i){
  do {
    //thinking		//思考
    p(count);		//判断是否超过四人准备进餐
    P(mutex[i]);	//判断缓冲池中是否仍有空闲的缓冲区
    P(mutex[(i+1)%5]);//判断是否可以进入临界区（操作缓冲池）
    //...
    //eat			//进餐
    //...
    V(mutex[i]);//退出临界区，允许别的进程操作缓冲池
    V(mutex[(i+1)%5]);//缓冲池中非空的缓冲区数量加1，可以唤醒等待的消费者进程
    V(count);//用餐完毕，别的哲学家可以开始进餐
  }while(true);
}

2. 当哲学家的左，右两只筷子均可用时，才允许他拿起筷子进餐

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量

void philosopher(int i){
  do {
    //thinking		//思考
    Swait(mutex[i], mutex[(i+1)%5]);//判断哲学家左边和右边的筷子是否同时可用
    //...
    //eat		
    //...
    Ssignal(mutex[i], mutex[(i+1)%5]);//进餐完毕，释放哲学家占有的筷子
  }while(true);
}

3. 规定奇数号的哲学家先拿起他左边的筷子，然后再去拿他右边的筷子；而偶数号的哲学家则先拿起他右边的筷子，然后再去拿他左边的筷子，此时需要在代码中添加个判断，来决定获取左、右筷子的顺序。

semaphore mutex[5] = {1,1,1,1,1}; 		//初始化信号量

void philosopher(int i){
  do {
    //thinking	
    if(i%2 == 1){
      P(mutex[i]);//判断哲学家左边的筷子是否可用
      P(mutex[(i+1)%5]);//判断哲学家右边的筷子是否可用
    }else{
      P(mutex[(i+1)%5]);//判断哲学家右边的筷子是否可用
      P(mutex[i]);//判断哲学家左边的筷子是否可用
    }
    //...
    //eat
    //...
    V(mutex[i]);//退出临界区，允许别的进程操作缓冲池
    V(mutex[(i+1)%5]);//缓冲池中非空的缓冲区数量加1，可以唤醒等待的消费者进程
  }while(true);
}

Deadlock(5分)

银行家算法

Memory

Memery allocation(5分)

• 按照成功率：最佳适应算法分配最高（合理分配，本次实验全部分配成功）
• 按照速率：首次适应算法最高（最佳和最差每一轮都需要排序）

Page replacment(15分)

FIFO

按照页面进入内存的顺序进行页面置换

LRU

最近最久未被使用的页面进行置换

LFU

最少的页面进行置换

OPT

最长时间内不会被访问的页面进行置换

分页式存储管理

File System(5分)

IO

Disk scheduling（15分）

先来先服务（FCFS）

最短寻道时间优先算法（SSTF）

扫描算法（SCAN）

循环扫描算法（CSCAN）