磁盘调度算法例子加练习
磁盘调度试验
实验四磁盘调度实验目的编程模拟实现磁盘调度的常用算法或调试分析相关磁盘调度程序, 加深对磁盘调度常用算法的理解和实现技巧。
实验内容1.自定义磁盘调度相关的数据结构；2.依据先来先服务算法（FCFS）、最短寻道优先算法（SSTF）、扫描(SCAN, 也称电梯)算法的原理, 编写对应函数, 模拟系统的磁盘调度服务；3.为了更好地模拟和评价算法的性能, 随机产生需寻道的磁道序列, 以磁道序列的首磁道为磁头的当前位置；在SCAN算法中, 允许用户指定当前寻道方向；4.统计以上算法总寻道次数和平均寻道距离；比较/分析以上算法的寻道性能, 并做出自己的评价。
实验步骤（源程序）#include<stdio.h>#include<stdlib.h>#include<iostream.h>#include<math.h>#define maxsize 1000int decide(char str[]) //判断输入数据是否有效{int i=0;while(str[i]!='\0'){if(str[i]<'0'||str[i]>'9'){return 0;break;}i++;}return i;}int trans(char str[], int a) //将字符串转换成数字{int i;int sum=0;for(i=0;i<a;i++){sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));}return sum;}int *bubble(int cidao[],int m){int i,j;int temp;for(i=0;i<m;i++) //使用冒泡法按从小到大顺序排列 for(j=i+1;j<m;j++){if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为: ";for( i=0;i<m;i++) //输出排序结果 {cout<<cidao[i]<<" ";}cout<<endl;return cidao;} int printnow(){char str[10];int a,now;cout<<"请输入当前的磁道号: ";A: cin>>str;a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入！ "<<endl;goto A;}elsenow=trans(str,a);return now;}int printout(int cidao[],int now,int m)int i;int sum=0;cout<<"磁盘扫描序列为: ";for(i=m-1;i>=0;i--){cout<<cidao[i]<<" ";sum+=abs(now-cidao[i]);now=cidao[i];}return sum;}int printin(int cidao[],int now,int m){int i;int sum=0;cout<<"磁盘扫描序列为: ";for(i=0;i<m;i++){cout<<cidao[i]<<" ";sum+=abs(cidao[m-1]-now);now=cidao[i];}return sum;}int prints(int cidao[],int now,int m,int l,int r) {int j;int sum=0;while(l>=0){cout<<cidao[l]<<" ";sum+=now-cidao[l];now=cidao[l];l=l-1;}now=cidao[0];for(j=r;j<m;j++){cout<<cidao[j]<<" ";sum+=cidao[j]-now;now=cidao[j];}return sum;int printl(int cidao[],int now,int m,int l,int r){int j;int sum=0;while(r<m){cout<<cidao[r]<<" ";sum+=cidao[r]-now;now=cidao[r];r=r+1;}now=cidao[m-1];for(j=l;j>=0;j--){cout<<cidao[j]<<" "; //输出磁盘调度序列sum+=now-cidao[j];now=cidao[j];}return sum;}void FCFS(int cidao[],int m) //磁道号数组, 个数为m {int now;float sum=0; //总寻道长度 int j,i;float ave;cout<<"磁盘请求序列为: ";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列 {cout<<cidao[i]<<" ";}cout<<endl;now=printnow(); //输入当前磁道号cout<<"磁盘扫描序列为: ";for( i=0;i<m;i++) //输出磁盘扫描序列{cout<<cidao[i]<<" ";}for(i=0,j=1;j<m;i++,j++) //求平均寻道长度{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<<endl;cout<<"平均寻道长度: "<<ave<<endl;}void SSTF(int cidao[],int m){int k=1;int now,l,r;int sum;float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序now=printnow(); //输入当前磁道号if(cidao[m-1]<=now) //若当前磁道号大于请求序列中最大者, sum=printout(cidao,now,m);if(cidao[0]>=now) //若当前磁道号小于请求序列中最小者, sum=printin(cidao,now,m);if(now>cidao[0]&&now<cidao[m-1]) //若当前磁道号大于请求序列中最小者且小于最大者{cout<<"磁盘扫描序列为: ";while(cidao[k]<now) //确定当前磁道在已排的序列中的位置, 后面的算法都用到了, 可以直接复制后少量修改, 节省时间。
实验报告六 磁盘调度算法
实验报告六磁盘调度算法班级：软技2班学号：201467003084 姓名：刘道林一．实验内容：熟悉磁盘的结构以及磁盘的驱动调度算法的模拟，编程实现简单常用的磁盘驱动调度算法先来先服务（FIFO）、电梯调度算法、最短寻找时间优先算法、扫描（双向扫描）算法、单向扫描（循环扫描）算法等。
编程只需实现两个算法。
题目可以选取教材或习题中的相关编程实例。
编程语言建议采用c/c++或Java。
模拟程序鼓励采用随机数技术、动态空间分配技术，有条件的最好能用图形界面展现甚至用动画模拟。
实验性质：验证型。
二．实验目的和要求1）掌握使用一门语言进行磁盘驱动调度算法的模拟；2）编写程序将磁盘驱动调度算法的过程和结果能以较简明直观的方式展现出来。
三．实验原理、方法和步骤1. 实验原理磁盘驱动调度对磁盘的效率有重要影响。
磁盘驱动调度算法的好坏直接影响辅助存储器的效率，从而影响计算机系统的整体效率。
常用的磁盘驱动调度算法有：最简单的磁盘驱动调度算法是先入先出（FIFO）法。
这种算法的实质是，总是严格按时间顺序对磁盘请求予以处理。
算法实现简单、易于理解并且相对公平，不会发生进程饿死现象。
但该算法可能会移动的柱面数较多并且会经常更换移动方向，效率有待提高。
最短寻找时间优先算法：总是优先处理最靠近的请求。
该算法移动的柱面距离较小，但可能会经常改变移动方向，并且可能会发生进程饥饿现象。
电梯调度：总是将一个方向上的请求全部处理完后，才改变方向继续处理其他请求。
扫描（双向扫描）：总是从最外向最里进行扫描，然后在从最里向最外扫描。
该算法与电梯调度算法的区别是电梯调度在没有最外或最里的请求时不会移动到最外或最里柱面，二扫描算法总是移到最外、最里柱面。
两端的请求有优先服被务的迹象。
循环扫描（单向扫描）：从最外向最里进行柱面请求处理，到最里柱面后，直接跳到最外柱面然后继续向里进行处理。
该算法与扫描算法的区别是，回来过程不处理请求，基于这样的事实，因为里端刚被处理。
操作系统磁盘调度算法例题讲解
操作系统磁盘调度算法例题讲解1. 磁盘调度算法的背景和意义磁盘调度算法是操作系统中的重要组成部分，它的主要目的是优化磁盘访问，提高磁盘I/O操作的效率。
在计算机系统中，磁盘是一个重要的存储介质，它负责存储和读写数据。
然而，由于磁盘访问具有机械运动延迟和寻道时间等特性，使得磁盘I/O操作成为计算机系统中一个性能瓶颈。
为了解决这个问题，人们提出了各种各样的磁盘调度算法。
这些算法通过优化访问顺序、减少寻道时间、提高数据传输率等方式来提高磁盘I/O操作效率。
因此，深入了解和掌握不同类型的磁盘调度算法对于优化计算机系统性能具有重要意义。
2. 先来先服务（FCFS）调度算法先来先服务（First-Come, First-Served）是最简单、最直观的一种磁盘调度算法。
它按请求顺序处理I/O请求。
当一个请求到达时，在当前位置完成当前请求后再处理下一个请求。
然而，在实际应用中，FCFS存在一些问题。
首先，它无法充分利用磁盘的带宽，因为磁盘的读写头可能在处理当前请求时，其他请求已经到达。
其次，由于磁盘请求的随机性，FCFS可能导致某些请求等待时间过长。
3. 最短寻道时间优先（SSTF）调度算法最短寻道时间优先（Shortest Seek Time First）是一种基于当前位置选择下一个最近请求的调度算法。
在SSTF算法中，选择离当前位置最近的请求进行处理。
SSTF算法相对于FCFS算法来说，在减少寻道时间方面有一定的优势。
它能够充分利用磁盘带宽，并且能够减少某些请求等待时间过长的问题。
然而，SSTF算法也存在一些问题。
首先，在某些情况下，由于选择最近的请求进行处理，可能导致某些较远位置上的请求长期等待。
其次，在高负载情况下，由于大量随机访问导致寻道距离变大，SSTF 算法可能会导致饥饿现象。
4. 扫描（SCAN）调度算法扫描（SCAN）是一种按一个方向依次处理I/O请求，并在到达边界后改变方向的调度算法。
SCAN算法从一个方向开始处理请求，直到到达磁盘的边界。
7.4.4 调度算法举例
例题1：假设在单道批处理环境下有四个作业，已知它们进入系统的时间、估计运行时间：应用先来先服务、最短作业优先和最高响应比优先作业调度算法，分别计算出作业的平均周转时间和带权的平均周转时间。
先来先服务算法计算结果：最短作业优先算法计算结果：最高响应比算法计算结果例题2：在两道环境下有四个作业, 已知它们进入系统的时间、估计运行时间，作业调度采用短作业优先算法，作业被调度运行后不再退出, 进程调度采用剩余时间最短的抢先调度算法（假设一个作业创建一个进程）。
请给出这四个作业的执行时间序列，并计算出平均周转时间及带权平均周转时间。
10：00，JOB1进入，只有一作业，JOB1被调入执行，10：05，JOB2到达，最多允许两作业同时进入，所以JOB2也被调入；内存中有两作业，哪一个执行？题目规定当一新作业运行后，可按作业运行时间长短调整执行次序；即基于优先数可抢占式调度策略，优先数是根据作业估计运行时间大小来决定的，由于JOB2运行时间（20分）比JOB1少（到10：05，JOB1还需25分钟），所以JOB2运行，而JOB1等待。
10：10，JOB3到达输入井，内存已有两作业，JOB3不能马上进入内存；10：20，JOB4也不能进入内存，10：25，JOB2运行结束，退出，内存中剩下JOB1，输入井中有两作业JOB3和JOB4，如何调度？作业调度算法：最短作业优先，因此JOB3进入内存，比较JOB1和JOB3运行时间，JOB3运行时间短，故JOB3运行，同样，JOB3退出后，下一个是JOB4，JOB4结束后，JOB1才能继续运行。
四个作业的执行时间序列为：JOB1：10：00—10：05，10：40—11：05 JOB2：10：05—10：25JOB3：10：25—10：30JOB4：10：30—10：40。
实验七 磁盘调度
实验七磁盘调度一、实验目的：磁盘是高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器，担负着繁重的输入输出工作，在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。
系统可采用一种策略，尽可能按最佳次序执行访问磁盘的请求。
由于磁盘访问时间主要受寻道时间T的影响，为此需要采用合适的寻道算法，以降低寻道时间。
本实验要求模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。
通过实验来理解和掌握磁盘调度的职能。
二、实验内容：分别模拟如下电梯调度算法，对磁盘进行移臂操作：●先来先服务算法●最短寻道优先算法●电梯算法三、实验要求：1、假设磁盘只有一个盘面，并且磁盘是可移动头磁盘。
2、磁盘是可供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时，其它想访问该磁盘的进程必须等待，直到磁盘一次工作结束。
当有多个进程提出输入输出请求而处于等待状态时，可用磁盘调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。
为此设置“驱动调度”进程。
3、由于磁盘与处理器是并行工作的，所以当磁盘在为一个进程服务时，占有处理器的其它进程可以提出使用磁盘（这里我们只要求访问磁道），即动态申请访问磁道，为此设置“接受请求”进程。
4、为了模拟以上两个进程的执行，可以考虑使用随机数来确定二者的允许顺序，参考程序流程图。
5、“接受请求”进程建立一张“进程请求I/O”表，指出等待访问磁盘的进程要求访问的磁道，表的格式如下：6、磁盘调度的功能是查“请求I/O”表，当有等待访问的进程时，按磁盘调度算法从中选择一个等待访问的进程，按其指定的要求访问磁道。
流程图中的“初始化”工作包括：初始化“请求I/O”表，设置当前移臂方向；当前磁道号。
并且假设程序运行前“请求I/O”表中已有若干进程（4～8个）申请访问相应磁道。
四、程序流程图：五．参考程序代码：#include <stdlib.h>#include<iostream.h>#include<cmath>typedef struct node{int data;struct node *next;}Node;void main(){void fcfs(Node *,int,int);//声明先来先服务函数FCFSvoid sstf(Node *,int,int);//声明最短寻道时间优先函数SSTFvoid scan(Node *,int,int);//声明扫描函数SCANvoid print(Node *); //输出链表函数Node *head,*p,*q; //建立一个链表int it,c=0,f,s; //c为链表长度,f是开始的磁道号,s是选择哪个算法head=(Node *)malloc(sizeof(Node));head->next=NULL;q=head;cout<<" /**************磁盘调度算法***************/"<<endl;cout<<endl;cout<<"新建一个单链表,以0作为结束标志:";cin>>it;while(it!=0){p=(Node *)malloc(sizeof(Node));p->next=NULL;p->data=it;q->next=p;q=p;cin>>it;c++;}cout<<"从几号磁道开始:";cin>>f; //f为磁道号print(head);cout<<"链表长度为:"<<c<<endl;cout<<"1、先来先服务算法FCFS"<<endl;cout<<"2、最短寻道时间优先算法SSTF"<<endl;cout<<"3、电梯调度算法(扫描算法SCAN)"<<endl;cout<<"0、退出"<<endl;cout<<"请选择:";cin>>s;while(s!=0){switch(s){case 1:cout<<"你选择了:先来先服务算法FCFS"<<endl;fcfs( head,c,f);break;case 2:cout<<"你选择了:最短寻道时间优先算法SSTF"<<endl;sstf( head,c,f);break;case 3:cout<<"你选择了:电梯调度算法(扫描算法SCAN)"<<endl;scan( head,c,f);break;}cout<<"退出请选0,继续请选1,2,3:";cin>>s;}}/***********************************************************/ void fcfs(Node *head,int c,int f)//先来先服务算法{void print(Node *);Node *l;//*m,*n;float num=0; //num为平均寻道长度l=head->next;for(int i=0;i<c;i++){num+=abs(l->data-f);f=l->data;l=l->next;}num=num/c;cout<<"先来先服务的寻道顺序是:"<<endl;print(head);cout<<"平均寻道长度:"<<num<<endl;}/*****************************************************************/ void sstf(Node *head,int c,int f)//最短寻道时间优先算法{void print(Node *);Node *p,*q,*r,*s,*l,*m;l=(Node *)malloc(sizeof(Node));l->next=NULL;m=l;q=head;p=head->next;s=head;r=head->next;float num=0;for(int i=0;i<c;i++){int min=abs(f-r->data);for(int j=0;j<c-i-1;j++){p=p->next;q=q->next;if(abs(f-p->data)<min){min=abs(f-p->data);r=p;s=q;}}num+=abs(f-r->data);f=r->data;s->next=r->next;r->next=NULL;m->next=r;m=r;q=head;p=head->next;s=head;r=head->next;}num=num/c;cout<<"最短寻道时间优先顺序是:"<<endl;print(l);cout<<"平均寻道长度:"<<num<<endl;}/***************************************************************/ void scan(Node *head,int c,int f)//扫描算法（电梯调度算法）{void print(Node *);int min,max,i=0,j=0;float num=0;Node *p,*q,*r,*s,*m,*n,*x,*y;r=(Node *)malloc(sizeof(Node));//存放比开始磁道小的磁道r->next=NULL;s=r;m=(Node *)malloc(sizeof(Node));//存放比开始磁道大的磁道m->next=NULL;n=m;x=(Node *)malloc(sizeof(Node));x->next=NULL;y=x;q=head;p=head->next;while(p->next!=NULL){if(p->data-f>0){q->next=p->next;p->next=NULL;n->next=p;n=p;p=q->next;i++;}else{q->next=p->next;p->next=NULL;s->next=p;s=p;p=q->next;j++;}}if(p->data>=f){n->next=p;n=p;i++;}else{s->next=p;s=p;j++;}q=r; //对比开始磁道小的磁道排序p=r->next;while(q->next->next!=NULL){q=q->next;p=q->next;max=q->data;while(p->next!=NULL){if(p->data>max){max=p->data;p->data=q->data;q->data=max;max=q->data;}p=p->next;}if(p->data>max){max=p->data;p->data=q->data;q->data=max;max=q->data;}}//print(r);q=m;p=m->next;while(q->next->next!=NULL){q=q->next;p=q->next;min=q->data;while(p->next!=NULL){if(p->data<min){min=p->data;p->data=q->data;q->data=min;min=q->data;}p=p->next;}if(p->data<min){min=p->data;p->data=q->data;q->data=min;min=q->data;}}//print(m);x=m;p->next=r->next;y=x->next;while(y->next!=NULL){num+=abs(f-y->data);f=y->data;y=y->next;}num+=abs(f-y->data);num=num/c;cout<<"扫描算法的顺序是:"<<endl;print(x);cout<<"平均寻道长度为:"<<num<<endl;}/*****************************************************/void print(Node *head) //输出链表{Node *p;p=head->next;cout<<"单链表显示:";if(p==NULL){cout<<"单链表为空:";}else if(p->next==NULL){cout<<p->data;}else{while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}}六．实验结果分析1. 假设磁盘访问序列： 89，138， 73，122，41，142，56，76，读写头起始位置：95分别按照下列调度算法安排磁头服务序列，并计算寻道距离。
磁盘调度算法实验报告
磁盘调度算法实验报告磁盘调度算法实验报告引言：磁盘调度算法是操作系统中的重要组成部分，它负责决定磁盘上数据的访问顺序，以提高磁盘的访问效率。
在本次实验中，我们对比了三种常见的磁盘调度算法：先来先服务（FCFS）、最短寻道时间优先（SSTF）和扫描（SCAN）算法。
通过对比实验结果，我们将分析不同算法的优缺点，并对其适用场景进行探讨。
实验过程：为了模拟磁盘调度算法在实际应用中的情况，我们使用了一个包含100个磁道的磁盘模型。
我们随机生成了一组磁道请求序列，并以此作为实验数据。
首先，我们使用FCFS算法对数据进行访问，记录下访问每个磁道所需的时间。
然后，我们分别使用SSTF和SCAN算法进行同样的操作，并记录下相应的访问时间。
实验结果：经过实验，我们得到了不同调度算法的访问时间数据。
在FCFS算法中，由于它按照请求的先后顺序进行访问，所以磁头需要频繁地在磁道之间移动，导致访问时间较长。
SSTF算法则根据当前磁头位置选择最近的磁道进行访问，因此其访问时间相对较短。
而SCAN算法则将磁头从一端移动到另一端，期间访问所有请求的磁道，这样可以减少磁头的移动次数，从而提高访问效率。
讨论与分析：从实验结果可以看出，不同的磁盘调度算法在不同的场景下有着不同的优势。
FCFS算法适用于请求较少、请求之间没有明显关联的情况。
因为它简单易实现，不需要额外的计算和判断，但在高负载情况下容易导致磁头抖动，降低整体性能。
SSTF算法适用于请求之间有明显关联的情况，因为它能够选择最近的磁道进行访问，减少了磁头的移动次数。
但是，当请求分布不均匀时，SSTF算法可能会导致某些磁道长时间得不到访问。
SCAN算法则适用于对整个磁盘进行扫描的场景，因为它能够在一个方向上连续访问多个磁道，减少了磁头的移动次数。
但是，SCAN算法可能会导致某些磁道长时间得不到访问，因此在请求分布不均匀的情况下，其性能可能会受到影响。
结论：通过本次实验，我们对比了三种常见的磁盘调度算法，并分析了它们的优缺点及适用场景。
操作系统-磁盘调度算法
操作系统-磁盘调度算法1 一次磁盘读/写操作需要的时间寻找时间（寻道时间）T s：在读/写数据前，需要将磁头移动到指定磁道所花费的时间。
寻道时间分两步：(1) 启动磁头臂消耗的时间：s。
(2) 移动磁头消耗的时间：假设磁头匀速移动，每跨越一个磁道消耗时间为m，共跨越n条磁道。
则寻道时间T s= s + m * n。
磁头移动到指定的磁道，但是不一定正好在所需要读/写的扇区，所以需要通过磁盘旋转使磁头定位到目标扇区。
延迟时间T R：通过旋转磁盘，使磁头定位到目标扇区所需要的时间。
设磁盘转速为r（单位：转/秒，或转/分），则平均所需延迟时间T R=(1/2)*(1/r) = 1/2r。
1/r就是转一圈所需的时间。
找到目标扇区平均需要转半圈，因此再乘以1/2。
传输时间T R：从磁盘读出或向磁盘中写入数据所经历的时间，假设磁盘转速为r，此次读/写的字节数为b，每个磁道上的字节数为N，则传输时间T R= (b/N) * (1/r) = b/(rN)。
每个磁道可存N字节数据，因此b字节数据需要b/N个磁道才能存储。
而读/写一个磁道所需的时间刚好是转一圈的时间1/r。
总的平均时间T a= T s+ 1/2r + b/(rN)，由于延迟时间和传输时间都是与磁盘转速有关的，且是线性相关。
而转速又是磁盘的固有属性，因此无法通过操作系统优化延迟时间和传输时间。
所以只能优化寻找时间。
2 磁盘调度算法2.1 先来先服务算法（FCFS）算法思想：根据进程请求访问磁盘的先后顺序进行调度。
假设磁头的初始位置是100号磁道，有多个进程先后陆续地请求访问55、58、39、18、90、160、150、38、184号磁道。
按照先来先服务算法规则，按照请求到达的顺序，磁头需要一次移动到55、58、39、18、90、160、150、38、184号磁道。
磁头共移动了 45 + 3 + 19 + 21 + 72 + 70 + 10 + 112 + 146 = 498个磁道。
实验六 磁盘调度算法
实验六磁盘调度算法【实验目的】通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法的实现方法。
【实验内容】问题描述：设计程序模拟先来先服务FCFS，最短寻道时间优先SSTF，SCAN 和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
程序要求如下：1）利用先来先服务FCFS，最短寻道时间优先SSTF，SCAN和循环SCAN算法模拟磁道访问过程。
2）模拟四种算法的磁道访问过程，给出每个磁道访问的磁头移动距离。
3）输入：磁道个数n和磁道访问序列，开始磁道号m和磁头移动方向（对SCAN和循环SCAN算法有效），算法选择1-FCFS，2-SSTF，3-SCAN，4-循环SCAN。
4）输出：每种算法的平均寻道长度。
【实验代码】#include <iostream>#include <fstream>#include <iomanip>#include <stdio.h>using namespace std;const int MaxNumber=100;int TrackOrder[MaxNumber];//磁盘访问序列int MoveDistance[MaxNumber];//磁头每次移动的距离double A verageDistance;//平均寻道长度bool direction;//SCAN和CSCAN算法的磁头移动方向int M;//开始磁道号int N;//磁道个数void inputData(){cout<<"请输入磁道个数N: ";cin>>N;cout<<"\n请输入磁盘访问顺序(此部分由文件读入)。
操作系统课程设计-磁盘调度算法
前言摘要：本课程设计的目的是通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，使磁盘调度的特点更简单明了，这里主要实现磁盘调度的四种算法，分别是：1、先来先服务算法（FCFS） 2、最短寻道时间优先算法（SSTF） 3、扫描算法（SCAN） 4、循环扫描算法（CSCAN）。
启动磁盘执行输入输出操作时，要把移动臂移动到指定的柱面，再等待指定扇区的旋转到磁头位置下，然后让指定的磁头进行读写，完成信息传送；因此，执行一次输入输出所花的时间有：寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。
延迟时间——指定扇区旋转到磁头下所需的时间。
传送时间——由磁头进程读写完成信息传送的时间，寻道时间——指计算机在发出一个寻址命令，到相应目标数据被找到所需时间；其中传送信息所花的时间，是在硬件设计时固定的，而寻找时间和延迟时间是与信息在磁盘上的位置有关；然后设计出磁盘调度的设计方式，包括算法思路、步骤，以及要用到的主要数据结构、函数模块及其之间的调用关系等，并给出详细的算法设计，对编码进行了测试与分析。
最后进行个人总结与设计体会。
关键词：最短寻道时间优先算法、扫描算法、总寻道长度.目录前言 (2)2. 课程设计任务及要求 (4)2.1 设计任务 (4)2.2 设计要求 (4)3. 算法及数据结构 (5)3.1算法的总体思想（流程） (5)3.2 实现过程中用到的数据结构 (6)3.3 实现过程中用到的系统调用 (11)4. 程序设计与实现 (11)4.1 最短寻道时间优先算法（SSTF）模块 (11)4.1.1程序流程图 (11)4.1.2 程序说明 (13)4.1.3 程序关键代码 (13)4.2扫描算法（SCAN）模块 (14)4.2.1 程序流程图 (14)4.2.2 程序说明 (16)4.2.3 程序关键代码 (16)4.3 实验结果 (17)5. 结论 (26)6. 参考文献 (26)7. 收获、体会和建议 (27)2. 课程设计任务及要求2.1 设计任务1.熟悉并掌握磁盘调度算法管理系统的设计方法，加强对所学各种调度算法及相应算法的特点了解。
磁盘调度算法实验要求及算法
磁盘调度算法编程序实现下述磁盘调度算法，并求出每种算法的平均寻道长度。
设计要求：（1）能够输入程序要访问的磁道序列和磁头当前所在的磁道数。
（2）可以选择某磁盘调度算法（先来先服务算法、最短寻道时间优先算法、扫描算法和循环扫描算法）。
（3）能够以下图形式显示磁盘调度顺序和平均寻道长度。
/*FCFS 先来先服务：根据进程请求访问磁盘的先后次序进行调度；SSTF 最短寻道时间优先：其要求访问的磁头与当前磁头所在的磁道距离最近，以使每次的寻道时间最短；SCAN 扫描算法：CSCAN 循环扫描算法：*/#include<iostream>using namespace std;#include<math.h>#define maxsize 1000int *bubble(int cidao[],int m) //使用冒泡法按从小到大顺序排列{int i,j;int temp;for(i=0;i<m;i++)for(j=i+1;j<m;j++){if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为：";for( i=0;i<m;i++) //输出排序结果{cout<<cidao[i]<<" ";}cout<<endl;return cidao;}void FCFS(int cidao[],int m) //磁道号数组，个数为m{int now;//当前磁道号int sum=0; //总寻道长度int j,i;float ave; //平均寻道长度cout<<"磁盘请求序列为：";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列{cout<<cidao[i]<<" ";}cout<<endl;cout<<"请输入当前的磁道号：";cin>>now ;sum+= abs(cidao[0]-now); //求绝对值cout<<"磁盘扫描序列为：";for( i=0;i<m;i++) //输出磁盘扫描序列{cout<<cidao[i]<<" ";}for(i=0,j=1;j<m;i++,j++) //求平均寻道长度{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<<endl;cout<<"平均寻道长度："<<ave<<endl;}void SSTF(int cidao[],int m) //磁道号数组，个数为m{int k=1;int now,l,r;int i,j,sum=0;float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序从小到大cout<<"请输入当前的磁道号：";cin>>now;if(cidao[m-1]<=now) //若当前磁道号大于请求序列中最大者，则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为：";for(i=m-1;i>=0;i--)cout<<cidao[i]<<" ";sum=now-cidao[0];}if(cidao[0]>=now) //若当前磁道号小于请求序列中最小者，则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为：";for(i=0;i<m;i++)cout<<cidao[i]<<" ";sum=cidao[m-1]-now;}if(now>cidao[0]&&now<cidao[m-1]) //若当前磁道号大于请求序列中最小者且小于最大者{cout<<"磁盘扫描序列为：";while(cidao[k]<now) //确定当前磁道在已排的序列中的位置，后面的算法都用到了，可以直接复制后少量修改，节省时间。
磁盘的调度算法
实验七磁盘的调度算法一.实验要求设计五个算法,分别是先来先服务算法,最短寻道时间优先算法,扫描(SCAN)算法,循环扫描(CSCAN)算法,NStepSCAN算法.由人工输入当前的磁道数,由系统随即生成要访问的磁道.二、开发环境操作系统:Rad Hat Linux ,开发环境:C语言.三、分析设计（一）实验原理.磁盘是可被多个进程共享的设备。
当有多个进程都请求访问磁盘时，应采用一种适当的调度算法，以使各进程对磁盘的平均访问(主要是寻道)时间最小。
由于在访问磁盘的时间中，主要是寻道时间，因此，磁盘调度的目标应是使磁盘的平均寻道时间最少。
(1) 先来先服务．(First-Come，First-Served，FCFS):这是一种简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
(2) 最短寻道时间优先(ShortestSeekTimeFirst，SSTF):该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。
(3) 扫描(SCAN)算法:SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
(4) 循环扫描(CSCAN)算法:处理该进程的请求，致使该进程的请求被严重地推迟。
实验磁盘调度算法
实验七：磁盘调度算法目录一．实验目的加深对磁盘的工作原理和调度效率的理解，掌握各种磁盘调度算法，模拟实现一种磁盘调度算法<SSTF、SCAN、CSCAN等）。
二．实验属性该实验为设计性实验。
三．实验仪器设备及器材普通PC386以上微机四．实验内容<1）先来先服务算法<FCFS）<2）最短寻道时间优先算法<SSTF）<3）扫描算法<SCAN）<4）循环扫描算法<CSCAN）五．实验步骤。
<1）先来先服务调度算法<FCFS）void FCFS(int a[],int n>{int sum=0,j,i,first=0,now。
cout<<"请输入当前磁道号："。
cin>>now。
//确定当前磁头所在位置cout<<"磁盘调度顺序为："<<endl。
for( i=0。
i<n。
i++>//按访问顺序输出磁道号{cout<<a[i]<<" "。
}//计算sumfor(i=0,j=1。
j<n。
i++,j++>{first+=abs(a[j]-a[i]>。
//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]>。
cout<<endl。
cout<<"移动的总磁道数： "<<sum<<endl。
}<2）最短寻道时间算法<SSTF）void SSTF(int a[],int n>{int temp。
int k=1。
int now,l,r。
int i,j,sum=0。
//将磁道号按递增排序for(i=0。
i<n。
i++>for(j=i+1。
j<n。
j++>{if(a[i]>a[j]>{temp=a[i]。
操作系统课程设计-磁盘调度算法
操作系统课程设计-磁盘调度算法前言摘要：本课程设计的目的是通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，使磁盘调度的特点更简单明了，这里主要实现磁盘调度的四种算法，分别是：1、先来先服务算法（FCFS） 2、最短寻道时间优先算法（SSTF） 3、扫描算法（SCAN） 4、循环扫描算法（CSCAN）。
启动磁盘执行输入输出操作时，要把移动臂移动到指定的柱面，再等待指定扇区的旋转到磁头位置下，然后让指定的磁头进行读写，完成信息传送；因此，执行一次输入输出所花的时间有：寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。
延迟时间——指定扇区旋转到磁头下所需的时间。
传送时间——由磁头进程读写完成信息传送的时间，寻道时间——指计算机在发出一个寻址命令，到相应目标数据被找到所需时间；其中传送信息所花的时间，是在硬件设计时固定的，而寻找时间和延迟时间是与信息在磁盘上的位置有关；然后设计出磁盘调度的设计方式，包括算法思路、步骤，以及要用到的主要数据结构、函数模块及其之间的调用关系等，并给出详细的算法设计，对编码进行了测试与分析。
最后进行个人总结与设计体会。
关键词：最短寻道时间优先算法、扫描算法、总寻道长度.3.2 实现过程中用到的数据结构1.最短寻道时间优先（SSTF）图a SSTF调度算法示例图ciidao[]={55,58,39,18,90,160,150,38,184}（可随机生成多个）用冒泡法对磁道数组进行排序用户输入当前磁道号now，比较当前返回内侧（外侧）扫描将当前磁道号与剩余没有图b SSTF算法流程示例图原磁道号随机组成的数组：cidao[]={55,58,39,18,90,160,150,38,184}；排序后的数组={18,38,39,5,58,90,150,160,184}；输入当前磁道号：now=100；3839 39 55 55 55 58 58 58 58 90 90 90 90 90 now值:100 90 58 55 39 184160 160150 150 15018 18 18 1838 38 38 3839 39 39 3955 55 55 5558 58 58 5890 90 90 90now值：18 150 160 184图c SSTF算法队列示意图(按磁道访问顺序)2.扫描（SCAN）算法图d SCAN算法示例图原磁道号随机组成的数组：cidao[]={55,58,39,18,90,160,150,38,184}；排序后的数组={18,38,39,5,58,90,150,160,184}；输入当前磁道号：now=100；选择磁道移动方向；以磁道号增加的方向移动为例：55 58 58 90 90 90 184 184 184 184 160 160 160 160 160 150 150 150 150 150 150 now值：100 150 160 184 90 58 1838 3839 39 3955 55 5558 58 5890 90 90184 184 184160 160 160150 150 150now值:55 39 38图e SCAN算法队列示意图（按磁道访问顺序）3.3 实现过程中用到的系统调用系统模块调用关系图4. 程序设计与实现4.1 最短寻道时间优先算法（SSTF ）模块4.1.1程序流程图磁盘调度算法最短寻道扫描算法退出4.1.2 程序说明算法分析①优点：相较于先来先服务算法（FCFS）有更好的寻道性能，使每次的寻道时间最短。
磁盘调度算法实验报告 (2)(优选.)
最新文件---------------- 仅供参考--------------------已改成-----------word文本 --------------------- 方便更改赠人玫瑰，手留余香。
磁盘调度算法学生姓名:学生学号:专业班级:指导老师：2013年6月20日1、实验目的：通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
2、问题描述：设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN 和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
3、需求分析通过这次实验，加深对磁盘调度算法的理解，进一步掌握先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的实现方法。
通过已知开始磁道数、访问磁道总数、磁道号访问序列、访问方向及访问方式得到访问序列及移动距离和平均移动距离！(1)输入的形式；int TrackOrder[MaxNumber];//被访问的磁道号序列int direction;//寻道方向int Num;//访问的磁道号数目int start;//(2)输出的形式；int MoveDistance[MaxNumber]={0};//移动距离double AverageDistance=0;//平均寻道长度移动的序列！(3)程序所能达到的功能；模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。
假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。
操作系统-第8章练习题
0、磁盘的驱动调度有“移臂调度”和“旋转调度”两部分组成。
常用的移臂调度算法有：先来先服务算法最短寻找时间优先算法电梯调度算法单向扫描算法。
(要注意题目要求的是哪种算法，求总移动距离还是平均移动距离)假设柱面的编号从0到199。
例如，如果现在读写磁头正在53号柱面上执行输入输出操作，而等待访问者依次要访问的柱面为98，183，37，122，14，124，65，67。
(1)．先来先服务调度算法当53号柱面上的操作结束后，访问柱面的次序为98，183，37，122，14，124，65，67。
读写磁头总共移动了640个柱面的距离。
(从53开始，每次移动距离之和，平均移动距离是640/8=80个柱面)(2)．最短寻找时间优先调度算法现在当53号柱面的操作结束后，访问次序为65、67、37、14，98，122，124，183。
读写磁头总共移动了236个柱面的距离。
(从53开始，每次找距离当前最近的进行移动)(3) 电梯调度算法由于该算法是与移动臂的方向有关，所以，应分两种情况来讨论。
(i)移动臂先向外移。
当前正在53号柱面执行操作的读写磁头是移动臂由里向外(向0号柱面方向)带到53号柱面的位置，因此，当访问53号柱面的操作结束后，依次访问的次序为37、14，65，67，98，122，124，183。
读写磁头共移动了208个柱面的距离。
(ii)移动臂先向里移。
当前正在53号柱面执行操作的读写磁头是移动臂由外向里(向柱面号增大方向)带到53号柱面的位置，因此，当访问53号柱面的操作结束后，依次访问的次序为65、67，98，122，124，183、37，14柱面的访问者服务。
读写磁头共移动了299个柱面的距离。
(总之象电梯一样，移动一个来回完成所有访问）(4)．单向扫描调度算法1. 一个磁盘组有100个柱面，每柱面8个磁道，每磁道8个扇区，现有一个文件含5000个记录，每记录与扇区大小相等，在磁盘组上顺序存放（从0面0道0扇区开始），问（1）第3468个记录的物理位置（2）第56个柱面上第7磁道第5扇区对应的块号。
操作系统磁盘调度算法例题讲解
操作系统磁盘调度算法例题讲解磁盘调度算法是操作系统中用于确定磁盘上数据访问顺序的算法。
它的目标是提高磁盘I/O的效率，减少磁盘访问时间。
以下是一个例题，我们通过讲解来了解磁盘调度算法的工作原理。
假设一个磁盘上有以下请求序列：98, 183, 37, 122, 14, 124, 65, 67。
磁头起始位置为53，磁道编号从0到199。
假设每个磁道的大小为1。
我们现在来分别讲解几种常见的磁盘调度算法如何处理这个请求序列：1. 先来先服务算法（First Come First Serve, FCFS）FCFS算法会按照请求的顺序进行处理。
根据给定的请求序列，磁头依次移动到98，然后到达183，再到37，以此类推。
计算总共移动的磁道数，得到结果为：98-53 + 183-98 + 183-37 + 122-37 + 122-14 + 124-14 + 124-65 + 67-65 = 640。
2. 最短寻道时间优先算法（Shortest Seek Time First, SSTF） SSTF算法会选择离当前磁头位置最近的请求进行处理。
对于请求序列98, 183, 37, 122, 14, 124, 65, 67，初始磁头位置为53，我们按照离当前位置最近的请求的顺序进行处理。
首先找到最近的请求是37，磁头移动到37，然后移动到14，继续移动到65，以此类推。
计算总共移动的磁道数，得到结果为：37-53 + 14-37 + 65-14 + 67-65 + 98-67 + 122-98 + 124-122 + 183-124 = 236。
3. 扫描算法（Scan）扫描算法，也叫电梯算法，是按照一个方向上的顺序进行移动，直到到达最上方或最下方，然后改变方向继续移动。
对于给定的请求序列，我们可以选择一个方向（向上或向下），然后依次处理请求。
对于本例中的请求序列，假设选择向上移动。
磁头依次移动到65，然后67，再到98，然后122，以此类推，直到183。
操作系统 实时调度算法例题(附图解)
1、在一个实时系统中,有三个周期性实时任务,任务A要求每20ms执行一次, 执行时间为10ms;任务B要求50ms执行一次,执行时间为10ms;任务C要求50ms执行一次,执行时间为15ms, 应如何按最低松弛度优先算法对它们进行CPU调度?解：松弛度=必须完成时间-其本身的运行时间-当前时间设任务A、B、C在t=0时同时到达，任务A和B每次必须完成的时间分别为：A1、A2、A3……和B1、B2、B3……t=0A1须在20ms时完成其本身运行时间是10msA1的松弛度=（20-10-0）ms=10msB1的松弛度=(50-10-0)ms=40msC1的松弛度=(50-15-0)ms=35ms所以可得到A1先执行，当A1执行完10ms后，只剩下了B1和C1 此时t=10msB1的松弛度=(50-10-10)ms=30msC1的松弛度=(50-15-10)ms=25ms所以可得到C1先执行，当C1执行到了t=25ms时A2的松弛度=（40-10-25）ms=5msB1的松弛度=(50-10-25)ms=15ms所以可得到A2先执行，当A2执行完10ms时t=35ms，只剩下了B1，接着执行B1，当B1执行完10ms时t=45ms，只剩A3，执行A3，当A3执行完10ms时t=55ms，此时B2的松弛度=（100-10-55)ms=35msC2的松弛度=（100-15-55)ms=30ms所以C2执行15ms此时t=70msA4的松弛度=（80-10-70）ms=0ms则A4执行10ms此时t=80ms，只剩下了A5和B2A5的松弛度=（100-10-80）ms=10msB2的松弛度=（100-10-80）ms=10ms因为B2先进入了就绪队列，所以B2先执行，执行10ms，再执行A5 同理依次往下计算……….如图所示，横轴代表t。
磁盘调度算法例子加练习
1先来先服务如下
最短寻找时间调度算法
电梯调度算法
若某磁盘共有200个磁道其编号为0199假设已完成68号磁道的访问请求正在为访问96号磁道的请求者服务还有若干个请求者在等待服务他们依次要访问的磁道号为
1．若某磁盘共有200个磁道，其编号为0～199，假设已完成68号磁道的访问请求，正在为访问96号磁道的请求者服务，还有若干个请求者在等待服务，他们依次要访问的磁道号为：175，52，157，36，159、106，l 08，72，(1)请分别计算用先来先服务调度算法、最短寻找时间调度算法、电梯调度算法来确定实际服务的次序。(2)按实际服务次序计算(1)中三种算法下移动臂需移动的距离。（向右）
循环扫描磁盘调度算法
循环扫描磁盘调度算法
哎呀呀，我是个小学生，啥是循环扫描磁盘调度算法呀？这名字听起来可真让人头疼！
就好像我们在学校里排队打饭，老师得安排谁先谁后。
磁盘调度算法也是这样，要决定先处理哪个数据。
循环扫描磁盘调度算法呢，就像是一个特别认真负责的管理员。
想象一下，磁盘就像一个超级大的操场，数据就是在操场上玩耍的小朋友。
这个管理员呀，不是随便乱指挥的。
他从一个地方开始，比如说从操场的最左边，然后朝着一个方向走，就像我们跑步比赛一样，一个接一个地处理小朋友们的事情。
比如说，有个小朋友叫数据A ，它在操场的这一头，管理员先去照顾它。
然后又碰到数据B ，也赶紧处理。
可是呢，如果一直这么走下去，走到操场的尽头了怎么办？这时候，管理员可不会像没头的苍蝇一样乱转，而是会马上转身，又从另外一边开始，继续处理没照顾到的小朋友。
这是不是很神奇？
我就想啊，这和我们做数学作业有点像。
我们得一道题一道题按顺序做，不能东一下西一下的。
循环扫描磁盘调度算法不也是这样按顺序来，才能把事情处理得井井有条嘛！
再比如说，我们打扫教室卫生的时候，也得有个顺序，从前面扫到后面，再从后面扫回来，这样才能把教室打扫干净呀。
反正我觉得，循环扫描磁盘调度算法虽然有点复杂，但是仔细想想，还是能明白它的道理的。
它就是为了让磁盘能更高效地工作，就像我们想要更高效地完成作业、打扫卫生一样！
我的观点就是：虽然循环扫描磁盘调度算法有点难理解，但只要多想想生活中的例子，就能搞明白啦！。