操作系统磁盘调度算法ava

实验六磁盘调度算法

1、实验目的

通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。

2、试验内容

问题描述：

设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN 和循环SCAN算法的工作过程。假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。

3、程序要求：

1）利用先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法模拟磁道访问过程。

2）模拟四种算法的磁道访问过程，给出每个磁道访问的磁头移动距离。

3）输入：磁道个数n和磁道访问序列，开始磁道号m和磁头移动方向（对SCAN 和循环SCAN算法有效），算法选择1-FCFS，2-SSTF，3-SCAN，4-循环SCAN。

4）输出：每种算法的平均寻道长度。

4、需求分析

(1) 输入的形式和输入值的范围

算法选择

要访问的磁道数

磁道

当前磁道号

输入当前移动臂的移动的方向（第三个算法）

(2) 输出的形式

每种算法的平均寻道长度

(3)测试用例

先来先服务FCFS

最短寻道时间优先

SCAN算法

CSCAN

5、调试分析

通过对这次操作系统实验，使我懂得了操作系统磁盘调度的四种算法：先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）和循环扫描算法（CSCAN）。加深了我对这门课程的理解。锻炼了自己在考虑全局也不是细节的能力。通过这次实验，再一次熟悉并深入掌握了程序设计语言和算法设计。

6、测试结果

(1)使用FCFS算法

输入

输出

(2)使用SSTF算法

输入

输出

(3)使用SCAN算法(向增长方向)

输入

输出

(4)使用SCAN算法(向减少方向)

输入

输出

(5)使用CSCAN算法

输入

输出

7、附录(java)

package experiment;

public class F_Disc_Dispatch {

private static int maxsize = 100;

// 要访问的磁道数

private static int count;

// 磁道

private static int cidao[] = new int[maxsize];

// 当前磁道号

private static int now;

// 总寻道长度

private static int sum = 0;

// 平均寻道长度

private static double AverageDistance;

// 当前移动臂的移动的方向 (1 (true)表示向外，0(false)表示向内)

private static boolean direction;

// 算法选择

// 1-使用FCFS算法

// 2-使用SSTF算法

// 3-使用SCAN算法

// 4-使用CSCAN算法

private static int option = 0;

// for循环用到变量

private static int i;

private static int j;

private static int k;

private static Scanner stdin;

public static void main(String[] args) throws FileNotFoundException { // 输入数据

input();

// int a;

switch (option) {

case 1: // 使用FCFS算法

FCFS();

break;

case 2: // 使用SSTF算法

SSTF();

break;

case 3: // 使用SCAN算法

SCAN();

break;

case 4: // 使用CSCAN算法

CSCAN();

break;

}

}

// 输入数据

public static void input() throws FileNotFoundException {

BufferedInputStream in = new BufferedInputStream(new FileInputStream( "./file/06"));

System.setIn(in);

stdin = new Scanner(System.in);

// 算法选择

// 1-使用FCFS算法

// 2-使用SSTF算法

// 3-使用SCAN算法

// 4-使用CSCAN算法

option = stdin.nextInt();

// 要访问的磁道数

count = stdin.nextInt();

// 磁道

for (i = 0; i < count; i++) {

cidao[i] = stdin.nextInt();

}

// 当前磁道号

now = stdin.nextInt();

if (option == 3) {

// 输入当前移动臂的移动的方向 (1 表示向外，0表示向内) :

try {

int g = stdin.nextInt();

if (g == 1) {

direction = true;

} else {

direction = false;

}

} catch (Exception e) {

// TODO: handle exception

return;

}

}

stdin.close();

}

/********************* 先来先服务调度算法 **************************/

public static void FCFS() {

sum += Math.abs(cidao[0] - now);

for (i = 0; i < count; i++) // 输出磁盘扫描序列

{

}

for (i = 0, j = 1; j < count; i++, j++) // 求平均寻道长度

{

sum += Math.abs(cidao[j] - cidao[i]);

AverageDistance = (float) (sum) / (float) (count);

}

}

/********************** 最短寻道时间优先调度算法 ********************/

public static void SSTF() {

k = 1;

int l, r;

bubble(); // 调用冒泡排序算法排序

if (cidao[count - 1] <= now) // 若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务

{

for (i = count - 1; i >= 0; i--) {

}

sum = now - cidao[0];

}

if (cidao[0] >= now) // 若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务{

for (i = 0; i < count; i++) {

}

sum = cidao[count - 1] - now;

}

if (now > cidao[0] && now < cidao[count - 1]) // 若当前磁道号大于请求序列中最小者且小于最大者

{

while (cidao[k] < now) // 确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。

{

k++;

}

l = k - 1;

r = k;

while ((l >= 0) && (r < count)) // 当前磁道在请求序列范围内

{

if ((now - cidao[l]) <= (cidao[r] - now)) // 选择与当前磁道最近的请求给予服务

{

sum += now - cidao[l];

now = cidao[l];

l = l - 1;

} else {

sum += cidao[r] - now;

now = cidao[r];

r = r + 1;

}

}

if (l == -1) // 磁头移动到序列的最小号，返回外侧扫描仍未扫描的磁道

{

for (j = r; j < count; j++) {

}

sum += cidao[count - 1] - cidao[0];

} else // 磁头移动到序列的最大号，返回内侧扫描仍未扫描的磁道

{

for (j = l; j >= 0; j--) {

}

sum += cidao[count - 1] - cidao[0];

}

}

AverageDistance = (float) (sum) / (float) (count);

}

/***************************** 扫描调度算法 *******************************/

public static void SCAN() // 先要给出当前磁道号和移动臂的移动方向

{

k = 1;

int l, r;

bubble(); // 调用冒泡排序算法排序

if (cidao[count - 1] <= now) // 若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务,此情况同最短寻道优先

{

for (i = count - 1; i >= 0; i--) {

}

sum = now - cidao[0];

}

if (cidao[0] >= now) // 若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务,此情况同最短寻道优先

{

for (i = 0; i < count; i++)

sum = cidao[count - 1] - now;

}

if (now > cidao[0] && now < cidao[count - 1]) // 若当前磁道号大于请求序列中最小者且小于最大者

{

while (cidao[k] < now) {

k++;

}

l = k - 1;

r = k;

if (direction == false) // 选择移动臂方向向内，则先向内扫描

{

for (j = l; j >= 0; j--) {

}

for (j = r; j < count; j++) // 磁头移动到最小号，则改变方向向外扫描未扫描的磁道

{

}

sum = now - 2 * cidao[0] + cidao[count - 1];

} else // 选择移动臂方向向外，则先向外扫描

{

for (j = r; j < count; j++) {

}

for (j = l; j >= 0; j--) // 磁头移动到最大号，则改变方向向内扫描未扫描的磁道

{

}

sum = -now - cidao[0] + 2 * cidao[count - 1];

}

}

AverageDistance = (float) (sum) / (float) (count);

}

/************************ 循环扫描调度算法 *****************************/

public static void CSCAN() {

k = 1;

int l, r;

bubble(); // 调用冒泡排序算法排序

if (cidao[count - 1] <= now) // 若当前磁道号大于请求序列中最大者，则直接将移动臂移动到最小号磁道依次向外给予各请求服务

{

for (i = 0; i < count; i++) {

}

sum = now - 2 * cidao[0] + cidao[count - 1];

}

if (cidao[0] >= now) // 若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务,此情况同最短寻道优先

{

for (i = 0; i < count; i++)

sum = cidao[count - 1] - now;

}

if (now > cidao[0] && now < cidao[count - 1]) // 若当前磁道号大于请求序列中最小者且小于最大者

{

while (cidao[k] < now) // 单向反复地从内向外扫描

{

k++;

}

l = k - 1;

r = k;

for (j = r; j < count; j++) {

}

for (j = 0; j < r; j++) // 当扫描完最大号磁道，磁头直接移动到最小号磁道，再向外扫描未扫描的磁道

{

}

sum = 2 * cidao[count - 1] + cidao[l] - now - 2 * cidao[0];

}

AverageDistance = (float) (sum) / (float) (count);

}

/********************* 冒泡排序算法 **************************/

public static void bubble() {

int temp;

for (int i = 0; i < count; i++) { // 使用冒泡法按从小到大顺序排列

for (int j = i + 1; j < count; j++) {

if (cidao[i] > cidao[j]) {

temp = cidao[i];

cidao[i] = cidao[j];

cidao[j] = temp;

}

}

}

for (i = 0; i < count; i++) // 输出排序结果

{

}

}

}

本文来源：https://www.bwwdw.com/article/gy0q.html