計算機操作系統—調度算法

# 有些計算會有問題諒解

經典進程的同步問題

1、吃水果

桌上有一只盤子，每次只能放入一只水果，爸爸專向盤子中放蘋果(apple)，媽媽專向盤子中放桔子(orange),一個兒子專等吃盤子中的桔子，一個女兒專等吃盤子中的蘋果。只要盤子中空則爸爸或媽媽可向盤子中放一只水果，僅當盤中有自己需要的水果時，兒子或女兒可從中取出。把爸爸、媽媽、兒子、女兒看做四個進程，用wait、signal操作進行管理，使這４個進程能正確地並發執行。如圖所示。

.png)

1、定義信號量的含義與賦值

定義一個是否允許向盤子中存放水果的信號量S，其初值為“1” ；定義兩個信號量SP和SO分別表示盤子中是否有蘋果或桔子的消息，初值均為“0” ，一個互斥信號量

\[SP=表示盤子中有蘋果；SO=表示盤子里面有桔子 \]

2、寫偽代碼

begin:
	S,SP,SO:semaphere;	//設置信號量
    	S:=1;	SP:=0;	SO:=0;	//進行初始賦值
            Process 爸爸{
            Begin
                L1:准備一個蘋果;
            	wait(S);	//申請空盤子的互斥信號量
                    將蘋果放入盤子中
                    signal(SP);	//盤子中有蘋果，返回SP
                    Goto L1;	//調用L1女兒取走盤子中的蘋果
                       end;
       		 }
			Process 媽媽{
            Begin
                L2:准備一個桔子;
            	wait(S);	//申請空盤子的互斥信號量
                    將桔子放入盤子中
                    signal(SO);	//盤子中有桔子，返回SO
                    Goto L2;	//調用L2兒子取走盤子中的桔子
                       end;
       		 }
			Process 兒子{
            begin
                L3:.wait(SO);	//等待盤子中有桔子
                    從盤子中拿走桔子
                    signal（S）;	//拿走桔子后，盤子為空；由SO向S轉變
                    end;
            }
			Process 女兒{
            begin
                L4:.wait(SP);	//等待盤子中有蘋果
                    從盤子中拿走蘋果
                    signal（S）;	//拿走蘋果后，盤子為空；由SP向S轉變
                    end;
            }
			end; 

2、共享打印機

現有四個進程R1，R2，W1，W2，它們共享可以存放一個數的緩沖區。進程R1每次把來自鍵盤的一個數存入緩沖區中，供進程W1打印輸出；進程R2每次從磁盤上讀一個數存放到緩沖區中，供進程w2打印輸出。為防止數據的丟失和重復打印，問怎樣用wait、signal操作來協調這四個進程的並發執行。

1、定義變量

定義一個是否允許向緩沖區中存放數據的信號量S，其初值為“1” ；定義兩個信號量SW1和SW2分別表示緩沖區中是否有數據R1與R2的消息，初值均為“0” ，一個互斥信號量

2、偽代碼

begin:
	S,SW1,SW2:semaphere;	//設置信號量
    	S:=1;	SW1:=0;	SW2:=0;	//進行初始賦值
    	Process R1{
    	begin:
    	wait(S);	//R1申請緩沖區
    		R1向緩沖區存入數據
    		signal（SW1）;
    		Goto W1;	//調用W1從緩沖區讀數據並打印
    	end;
    	}
    	Process R2{
    	wait(S);	//R2申請緩沖區
    	R2向緩沖區存入數據;
    	signal(SW2);	
    	Goto W2;	//調用W2從緩沖區讀數據並打印
    	end;
    	}
    	Process W1{
    	wait(SW1);	//申請SW1緩沖區
    	讀取並打印SW1;
    	signal(S);	//釋放緩沖區的數據
    	end;
    	}
    	Process W2{
    	wait(SW2);	//申請SW2緩沖區
    	讀取並打印SW2;
    	signal(S);	//釋放緩沖區的數據
    	end;
    	}
    	end

3、超市購物

某超市，可容納100人同時購物，入口處備有籃子。每個購物者持一只籃子入內購物，出口處結帳，並歸還籃子（出、入口僅容一人通過）。試用信號量和wait、signal操作寫出購物同步算法。

1、分析：

超市最多可容納100人同時購物，當超市人滿時，其他購物者必須等待，而有人離開時，應允許等待者進入，因此需設一同步信號量來實現有限數目的購物者進入超市。另外因為出、入口僅容一人通過，所以多個購物者必須互斥通過出、入口，需設兩個互斥信號量。

2、定義信號量

S—表示是否可以進入超市，初值為100
互斥信號量：

• mutex1—用於多個購物者互斥通過入口取籃子。初值為1。
• mutex2—用於多個購物者互斥通過出口結賬、還籃子。初值為1。

3、偽代碼：

  begin 
    S, mutex1, mutex2 : semaphore; 
    S:=100;mutex1:=1; mutex2:=1; 
    cobegin 
    PROCESS	consumer.j;(j=1,2,…,r) 
  begin 
    wait(S);	//超市人滿時，購物者進程必須等待 
    wait(mutex1);			//進入入口臨界區 
    {在入口處取籃子，進入超市}; 
  signal(mutex1);	//退出臨界區 
    {在超市購物}； 
  wait(mutex2);	//進入出口臨界區 
    {在出口處放籃子，結賬}; 
  signal(mutex2);	//退出臨界區 
  signal(S)；	//允許等待者進入 
end; coend; end; 

4、哲學家進餐

有五個哲學家，他們的生活方式是交替地進行思考和進餐。他們共用一張圓桌，分別坐在五張椅子上。在圓桌上有五個碗和五支筷子，平時一個哲學家進行思考，飢餓時便試圖取用其左、右最靠近他的筷子，只有在他拿到兩支筷子時才能進餐。進餐畢，放下筷子又繼續思考。
哲學家進餐問題可看作是並發進程並發執行時，處理共享資源的一個有代表性的問題。

1、問題分析：

放在桌上的每只筷子是臨界資源，一段時間內只由一位哲學家使用。為了實現對筷子的互斥使用，需要用一個信號量表示一只筷子。5個信號量則構成信號量數組。

Var chopstick: array［0, …, 4］ of semaphore;
所有信號量均被初始化為1， 第i位哲學家的活動可描述為： 
repeat
	 wait(chopstick［i］);/*試圖拿右邊(編號為順時針時)的筷子*/

    	wait(chopstick［(i+1) mod 5］);/*試圖拿左邊的筷子*/
      		…
   	 eat;
                            ...
   	 signal(chopstick［i］);/放下右邊的筷子*/

	 signal(chopstick［(i+1) mod 5］); /*放下左邊的筷子*/
     	            …
   	 think;
  until false; 

若五位哲學家同時飢餓而各自拿起了右邊的筷子，這使五個信號量stick均為0，當他們試圖去拿起左邊的筷子時，都將因無筷子而無限期地等待下去，即可能會引起死鎖。

Var chopsiick array ［0, …, 4］ of semaphore∶   =(1,1,1,1,1);
 process i
        repea
     think;
     Swait(chopstick［(i+1) mod 5］, chopstick ［i］);
     eat;
 Ssignat(chopstick ［(i+1) mod 5］, chopstick ［i］);
 until false;

5、讀者—寫者問題

在計算機系統中，有些文件是可以供若干進程共享的。假定有某個共享文件F，系統允許進程對文件F讀或修改(寫)，但規定：

1. 多個進程可以同時讀文件F任一個進程在對文件F
2. 進行修改(寫)時不允許其他進程對文件進行讀或修改當有進程在讀文件時不允許任何進程去修改(寫)文件。
3. 一個文件可能被多個進程共享，為了保證讀寫的正確性和文件的一致性，系統要求，當有讀者進程讀文件時，不允許任何寫者進程寫，但允許多讀者同時讀；當有寫者進程寫時，不允許任何其它寫者進程寫，也不允許任何讀者進行讀。

單純使用信號量不能解決讀者寫者問題,必須引入計數器readcount對讀進程計數,rmutex是用於對計數器readcount操作的互斥信號量, wmutex表示是否允許寫的信號量.

1、設置信號量

設置一個共享變量和兩個信號量：

1. 共享變量Readcount：記錄當前正在讀數據集的讀進程數目，初值為0。
2. 讀互斥信號量rmutex ：表示讀進程互斥地訪問共享變量readcount，初值為1.
3. 寫互斥信號量wmutex：表示寫進程與其它進程（讀、寫）互斥地訪問數據集，初值為1.

2、偽代碼

begin：
rmutex, wmutex:semaphore:=1;	//設置信號量初始值

    Readcount:integer∶=0;	//初始化正在讀當前文件的數量
    begin
    parbegin
     Reader:begin
        repeat
         wait(rmutex);{	//申請讀的互斥信號量，表示當前文件正在被讀
   if readcount=0 then wait(wmutex);;/*第一位讀者阻止寫者*/
   Readcount∶   =readcount+1;
         signal(rmutex);
           …
         perform read operation;
           …
	end;
     }
wait(rmutex);{		//申請讀的信號量，表示文件准備開始寫入數據
         readcount∶   =readcount-1;	//減少正在讀該文件數量--1
     if readcount=0 then signal(wmutex);	 /*第末位讀者允許寫者進*/
         signal(rmutex);
        until false;	//沒有人在讀這份文件
       end
}

writer:begin
        repeat
         wait(wmutex);			//阻止其它進程（讀、寫）進/
         perform write operation
         signal(wmutex);	//允許其它進程（讀、寫）進/

        until false;
       end
    parend
  end

調度算法

先來先服務（FCFS）調度算法

基本思想：按作業（進程）到達時間的先后順序依次使用處理機。可用於作業調度和進程調度。

特點：FCFS 調度算法有利於長作業（進程），不利於短作業（進程）

缺點：會使許多短作業等待很長的時間，從而引起許多短作業用戶的不滿。

進程名	到達時間	服務時間	開始執行時間	完成時間	周轉時間	帶權周轉時間
A	0	1	0	1	1	1
B	1	100	1	101	100	1
C	2	1	101	102	100	100
D	3	100	102	202	199	1.99

\[周轉時間=完成時間-到達時間;帶權周轉時間=\frac{完成時間-到達時間}{服務時間} \]

短作業優先（SJF）調度算法（非搶占式）

基本思想：對短作業（短進程）優先調度的算法,可用於作業調度和進程調度。

特點：有利於短作業（進程），不利於長作業（進程）

優點：能有效降低作業的平均等待時間；提高吞吐量；能有效縮短進程的周轉時間；

缺點：對長作業不利；不考慮作業的緊迫程度；作業執行時間僅為估計值；人機無法實現交互

進程名	到達時間	服務時間	完成時間	周轉時間	帶權周轉時間
A	0	4	4	4	1
B	1	3	9	8	2.67
C	2	5	18	16	3.2
D	3	2	6	3	1.5
E	4	4	13	9	2.25

短作業優先（SJF）調度算法（搶占式）

進程名	到達時間	服務時間	周轉時間	帶權周轉時間
A	0	1	1	1
B	1	100	101	1.01
D	2	100	200	2
C	3	1	1	1

高響應比優先調度算法（HRRN）

\[優先權=\frac{等待時間+要求服務時間}{要求服務時間}-\frac{響應時間}{要求服務時間}=R \]

特點：同時照顧了長短作業（進程），增加了系統開銷

例如有四個作業：

若采用響應比高者優先調度算法，求作業的調度順序。

\[響應比=\frac {所需要CPU時間(CPU執行時間)+已經等待時間}{CPU所需要時間(CPU執行時間)} \]

作業	到達時間	所需CPU時間
1	8.2	2
2	9.4	1
3	9.5	0.8
4	9.8	0.2

若采用響應比高者優先作業調度算法，先將作業1投入運行，於10.2完成，此時：

作 業	到達時間	所需CPU時間	已等待時間	響應比
2	9.4	1	10.2-9.4=0.8	1.8
3	9.5	0.8	10.2-9.5=0.7	1.875
4	9.8	0.2	10.2-9.8=0.4	3

由於作業4有最高響應比，因此被調度投入運行，於10.4完成，此時

作 業	到達時間	所需CPU時間	已等待時間	響應比
2	9.4	1	10.4-9.4=1	2
3	9.5	0.8	10.4-9.5=0.9	2.125

輪轉調度算法（RR）

基本思想：把CPU的處理時間分成固定大小的時間片，如果一個進程在調度中被選中后，用完系統規定的時間片任然沒有完成任務，則讓出處理機，並排到就緒隊列末尾。同時進程調度程序又調度當前就緒隊列對首的第一個進程投如運行。

特點：系統能在給定的時間內，響應所有用戶的請求。

例如:假定在一台處理機上要運行以下作業1,2,3,4,5.且假定這些作業在時刻0到達,他們的執行時間分別是:10、1、2、1、5。用時間片輪轉法，當q=1時，各作業的周轉時間和帶權周轉時間各是多少？

作業	服務時間	進入時刻	完成時刻	周轉時間	帶權周轉時間
1	10	0	19	19	1.9
2	1	0	2	2	2
3	2	0	7	7	3.5
4	1	0	4	4	4
5	5	0	14	14	2.8

軌跡如下：

運行時間(1S)	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19
作業順序	1	2	3	4	5	1	3	5	1	5	1	5	1	5	1	1	1	1	1

銀行家算法：

數據結構：

可用資源[Avaliable]	表示系統中可用的資源數目
最大需求矩陣[Max]	定義每一個進程對某種資源的最大需求
分配矩陣[Allocation]	每一個進程當前已經分配的某種資源數量
需求矩陣[Need]	表示一個進程還需要多少某種資源數量（需求不能超出可用資源數量和最大需求資源）

\[Request_i[j] \leq Need[i,j] \longrightarrow^F 出錯 \\ \\ \downarrow^T\\ Request_i[j] \leq Available[i,j] \longrightarrow^F 出錯 \\ 試探分配；修改數據結構 (一加兩減) \\ (系統)Available[j]:=Available[j]-Request_i[j]; \\ (進程)Allocation[i,j]=Allocation[i,j]+Request_i[j]; \\ (進程)Need[i,j]=Need[i,j]-Request_i[j]; \\ 進行安全檢測(安全算法)\longrightarrow^T真正分配 \\ \downarrow^F \\ 不分配，恢復到修改前的數據結構\\ \]

假定系統中有五個進程{P0, P1, P2, P3, P4}和三類資源{A, B, C},各種資源的數量分別為10、5、7,在T0時刻的資源分配情況如圖所示。

進行與資源數	MAX A B C	Allocation A B C	Need A B C	Available A B C
P0	7 5 3	0 1 0 0 3 0	7 4 3 7 2 3	3 3 2 2 3 0 2 1 0
P1	3 2 2	2 0 0 3 0 2	1 2 2 0 2 0
P2	9 0 2	3 0 2	6 0 0
P3	2 2 2	2 1 1	0 1 1
P4	4 3 3	0 0 2 1 0 3	4 3 1 3 3 0

求：系列問題

1. T0時刻的安全性
2. P1發出請求向量Request（1,0,2），系統能否將資源分配給它？
3. 在問題2的基礎上，P4發出請求向量Request（3,3,0），系統能否將資源分配給它？
4. 在問題2與問題3的基礎上，P0發出請求向量Request（0,2,0），系統能否將資源分配給它？

1、T0時刻的安全性

進行與資源數	work A B C	Need A B C	Allocation A B C	work+Allocation A B C	finsh
P1	3 3 2	1 2 2	2 0 0	5 3 2	ture
P3	5 3 2	0 1 1	2 1 1	7 4 3	ture
P4	7 4 3	4 3 1	0 0 2	7 4 5	ture
P2	7 4 5	6 0 0	3 0 2	10 4 7	ture
P0	10 4 7	7 4 3	0 1 0	10 5 7	ture

\[能找到一條安全序列:P1 \longrightarrow P3 \longrightarrow P4 \longrightarrow P2 \longrightarrow P0 \]

2、P1發出請求向量Request（1,0,2），系統能否將資源分配給它？

進行與資源數	work A B C	Need A B C	Allocation A B C	work+Allocation A B C	finsh
P1	3 3 2	1 2 2	2 0 0	5 3 2	ture
P3	5 3 2	0 1 1	2 1 1	7 4 3	ture
P4	7 4 3	4 3 1	0 0 2	7 4 5	ture
P0	7 4 5	7 4 3	0 1 0	7 5 5	ture
P2	7 5 5	6 0 0	3 0 2	10 5 7	ture

\[能找到一條安全序列:P1 \longrightarrow P3 \longrightarrow P4 \longrightarrow P0 \longrightarrow P2 \]

3、在問題2的基礎上，P4發出請求向量Request（3,3,0），系統能否將資源分配給它？

\[因為P4發出請求向量Request（3,3,0）\geq Available(2,3,0) 無法通過安全性檢查，並恢復到未分配狀態 \]

4、在問題2與問題3的基礎上，P0發出請求向量Request（0,2,0），系統能否將資源分配給它？

進行試探性分配后,可用資源Available(2,1,0)已不能滿足任何進程的需要。系統進入不安全狀態,所以系統不能將資源給P0進程。

連續分配存儲管理方式

基於順序搜索的動態分區分配算法

首次適應算法（FF）

原理：要求空閑分區表/鏈以地址遞增的次序鏈接空閑分區。從表/鏈首開始查找，直至第一個滿足要求的空閑分區。按作業的大小，從該分區中划出一塊空間，余下部分留在空閑表/鏈中。

特點：優先利用內存低地址部分的空閑分區,從而保留了高地址部分的大空閑區。但由於低地址部分不斷被划分,致使低地址端留下許多難以利用的很小的空閑分區(內部碎片),而每次查找又都是從低地址部分開始, 增加了查找可用空閑分區的開銷。

例 ：系統中的空閑分區表如下，現有三個作業分配申請內存空間100K、30K及7K。給出按首次適應算法的內存分配情況

空閑分區表

區號	大小	起址
1	32k	20k
2	8k	52k
3	120k	60k
4	331k	180k

解：按首次適應算法，

申請作業100k，分配3號分區，剩下分區為20k，起始地址160K ；

申請作業30k，分配1號分區，剩下分區為2k，起始地址50K ；

申請作業7k，分配2號分區，剩下分區為1k，起始地址59K ；

循環首次適應算法（CFF）

原理：要求空閑分區表/鏈以地址遞增的次序鏈接空閑分區，從上次找到空閑分區的下一個空閑分區開始查找，直至找到一個能滿足要求的空閑分區。按作業的大小，從該分區中划出一塊空間，余下部分留在空閑表/鏈中。

算法特點：使存儲空間的利用更加均衡，不致使小的空閑區集中在存儲區的一端，但這會導致缺乏大的空閑分區。

例 ：系統中的空閑分區表如下，現有三個作業分配申請內存空間100K、30K及7K。給出按循環首次適應算法的內存分配情況

空閑分區表

區號	大小	起址
1	32k	20k
2	8k	52k
3	120k	60k
4	331k	180k

解：按循環首次適應算法，

申請作業100k，分配3號分區，剩下分區為20k,起始地址160K；

申請作業30k，分配4號分區，剩下分區為301k，起始地址210K ；

申請作業7k，分配1號分區，剩下分區為25k，起始地址27K ；

最佳適應算法（BF）

原理：要求空閑分區表/鏈以空閑分區容量以小到大的次序鏈接空閑分區，從表/鏈首開始查找，直至找到一個能滿足要求的空閑分區。按作業的大小，從該分區中划出一塊空間，余下部分留在空閑表/鏈中。

算法特點:空閑區一般不可能正好和它申請的內存空間大小一樣,因而將其分割成兩部分時,往往使剩下的空閑區非常小,從而在存儲器中留下許多難以利用的小空閑區（內部碎片）。

例 ：系統中的空閑分區表如下，現有三個作業分配申請內存空間100K、30K及7K。給出按最佳適應算法的內存分配情況

分配前的空閑分區表

區號	大小	起址
1	8k	52k
2	32k	20k
3	120k	60k
4	331k	180k

解：按最佳適應算法，分配前的空閑分區表如上表。

申請作業100k，分配3號分區，剩下分區為20k,起始地址160K；

申請作業30k，分配2號分區，剩下分區為2k，起始地址50K ；

申請作業7k，分配1號分區，剩下分區為1k，起始地址59K ；

最壞適應算法（WF）

原理：要求空閑分區表/鏈以空閑分區容量以大到小的次序鏈接空閑分區，從表/鏈首開始查找，直至找到一個能滿足要求的空閑分區。按作業的大小，從該分區中划出一塊空間，余下部分留在空閑表/鏈中。

特點：總是挑選滿足作業要求的最大的分區分配給作業。這樣使分給作業后剩下的空閑分區也較大，可裝下其它作業。但由於最大的空閑分區總是因首先分配而划分，當有大作業到來時，其存儲空間的申請往往會得不到滿足。

例 ：系統中的空閑分區表如下，現有三個作業分配申請內存空間100K、30K及7K。給出按最壞適應算法的內存分配情況

空閑分區表

區號	大小	起址
1	331k	180k
2	120k	60k
3	32k	20k
4	8k	52k

解：按最壞適應算法，分配前的空閑分區表如上表。

申請作業100k，分配1號分區，剩下分區為231k,起始地址280K；

申請作業30k，分配1號分區，剩下分區為201k，起始地址310K ；

申請作業7k，分配1號分區，剩下分區為194k，起始地址317K ；

基本分頁存儲管理方式

頁面置換算法

缺頁率：在進程運行過程中，訪問頁面成功（所訪問的頁面在內存中）的次數為S，訪問頁面失敗（所訪問的頁面不在內存中，需要從外存調入）的次數為F，則該進程總的頁面訪問次數為A=S+F,該進程在其運行過程中的缺頁率為 f=F/A

影響缺頁率的因素：分配給進程的物理塊數；頁面本身的大小；程序的編制方法；頁面置換算法

最佳(Optimal)置換算法（理想化算法)

算法思想： 選擇將來不再被使用，或者最長時間不再被訪問的頁面將其淘汰。（往后看）

最佳置換算法產生的缺頁中斷次數最少，可獲得最低的缺頁中斷率。但是由於無法預知哪個頁面是未來最長時間內不被訪問的，所以該算法只是一種理論上的算法，可用該算法評價其它算法的優劣。

假設系統為某進程分配了三個物理塊，程序訪問頁面的順序為7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1

7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
7	7	7	2		2		2			2			2				7
	0	0	0		0		4			0			0				0
		1	1		3		3			3			1				1
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20

缺頁次數6次；缺頁率：6/20 應該是置換率吧

先進先出置換算法(FIFO)

算法思想：選擇最先進入內存的頁面將其淘汰。

先進先出(FIFO)置換算法實現簡單，但與進程實際運行的規律不適應

7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
7	7	7	2		2	2	4	4	4	0			0	0			7	7	7
	0	0	0		3	3	3	2	2	2			1	1			1	0	0
		1	1		1	0	0	0	3	3			3	2			2	2	1
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20

缺頁次數12次；缺頁率：12/20

最近最久未使用置換算法（LRU）

算法思想：選擇最近最久沒有使用的頁面將其淘汰。

最近最久未使用置換算法（LRU）的性能接近於最佳算法，但實現起來較困難。因為要快速找出最近最久未使用的頁面，需要兩類硬件之一的支持：寄存器或棧

7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
7	7	7	2		2		4	4	4	0			1		1		7
	0	0	0		0		0	0	3	3			3		0		0
		1	1		3		3	2	2	2			2		2		1
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20

Clock置換算法

簡單的Clock置換算法：每頁設置一個訪問位，並將內存中的所有頁鏈接成一個循環隊列。當某頁被訪問時，系統將其訪問位設置為1。置換時采用一個指針，從當前指針位置開始按序檢查各頁，若訪問位為0則選擇該頁換出，若訪問位為1則將其設置為0，最后指針停留在被置換頁的下一頁上。

改進型Clock算法：訪問位（A位）和修改位（M位）

A=0，M=0：未訪問，未修改，為最佳淘汰頁； A=0，M=1：未訪問，已修改，並不是很好的淘汰頁；

A=1，M=0：已訪問，未修改，有可能再次被訪問； A=1，M=1：已訪問，已修改，有可能再次被訪問；

磁盤調度算法

先來先服務FCFS

基本思想：根據進程請求訪問磁盤的先后次序進行調度

特點：簡單、公平，但平均尋道時間長。

（從100號磁道開始）
被訪問的下一個磁道號	移動距離（磁道數）
55	45
58	3
39	19
18	21
90	72
160	70
150	10
38	112
184	146
平均尋道長度：55.3

最短尋道時間優先SSTF

基本思想：優先選擇距當前磁頭最近的訪問請求進行服務

特點：改善了磁盤平均服務時間，但容易造成某些訪問請求長期等待得不到服務

（從100號磁道開始）
被訪問的下一個磁道號	移動距離（磁道數）
90	10
58	32
55	3
39	16
38	1
18	20
150	132
160	10
184	24
平均尋道長度：27.5

掃描算法SCAN（電梯算法）

基本思想：磁頭從磁盤的一端開始向另一端移動，沿途響應訪問請求，直到到達了磁盤的另一端，此時磁頭反向移動並繼續響應服務請求。

特點：尋道性能較好，避免了飢餓，但不利於遠離磁頭一端的訪問請求。

（從100號磁道開始，向磁道號增加方向訪問）
被訪問的下一個磁道號	移動距離（磁道數）
150	50
160	10
184	24
90	94
58	32
55	3
39	16
38	1
18	20
平均尋道長度：27.8

循環掃描算法CSCAN

基本思想：類似於掃描算法，但磁頭只能單向移動

特點：消除了對兩端磁道請求的不公平。

（從100號磁道開始，向磁道號增加方向訪問）
被訪問的下一個磁道號	移動距離（磁道數）
150	50
160	10
184	24
18	166
38	20
39	1
55	16
58	3
90	32
平均尋道長度：35.8

• [*] PDF：操作系統調度算法.pdf \(\\\)

• [*] PDF：操作系統基礎.pdf