1. Toy模板网首页
  2. > Toy博客

磁盘调度算法（操作系统实验 C＋＋）

7月前 作者：落灬枫 分类：Toy博客 阅读(42) 违法举报

这篇具有很好参考价值的文章主要介绍了磁盘调度算法（操作系统实验 C＋＋）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

磁盘调度算法

1.实验目的

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

2.实验内容

问题描述：
设计程序模拟先来先服务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）输出：每种算法的平均寻道长度。
实现提示：
用C++语言实现提示：
1）程序中变量定义参考（根据需要可添加）如下：
const int MaxNumber=100;
int TrackOrder[MaxNumber];
int MoveDistance[MaxNumber];
double AverageDistance;
bool direction;
2）页面置换的实现过程如下：
变量初始化；

  • 接收用户输入磁道个数n和磁盘访问序列，选择算法1-FCFS，2-SSTF，3-SCAN，4-循环SCAN，输入开始磁盘号m和磁头移动方向；

  • 根据用户选择的算法进行磁道访问，输出磁盘调度算法的模拟过程；

  • 计算选择每次移动的磁头移动距离和算法的平均寻道长度；

  • 输出选择算法的平均寻道长度。

实验要求：
1）上机前认真复习磁盘调度算法，熟悉FCFS、SSTF、SCAN和循环SCAN算法的过程；
2）上机时独立编程、调试程序；
3）根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源 程序、实例运行结果截图、发现的问题以及解决方法）。

3.程序主要构成部分及其算法说明

1.FCFS（先来先服务算法）
先对队列进行初始化，计算开始磁道号和队列中的第一个磁道号的距离，然后按照输入顺序依次访问磁道，计算移动距离，最后计算平均寻道长度。

void FCFS(){
    initial();  
 	 cout<<"FCFS"<<endl;
   
MoveDistance[0] = abs(TrackOrder[0]-StartTrack);
VisitOrder[i] = TrackOrder[i];
SumDistance = MoveDistance[0];

    for (int i=1;i<TrackNum;i++){
        MoveDistance[i] = abs(TrackOrder[i]-TrackOrder[i-1]);、
		 VisitOrder[i] = TrackOrder[i];
        SumDistance += MoveDistance[i];
    }
    AverageDistance = SumDistance*1.0/TrackNum;
    output();
}
  1. SSTF（最短寻找时间优先）
    先对队列进行初始化，然后用嵌套for循环计算，内部的第一个for循环先用来计算序列中所有磁道和第一个磁道（赋值给CurrentTrack）的距离存放在数组distance中，然后用第二个for循环找到距离最近的序列号pointMin，计算距离和记录位置后将pointMin赋值给CurrentTrack，然后外部for循环这个过程，对已经访问过的磁道给其一个较大的值，防止其再次被访问。
void SSTF(){
    initial();
    cout<<"SSTF"<<endl;
    int CurrentTrack = StartTrack;
    int i,j,pointMin;
    int distance[MaxNumber];
 
    for (i = 0;i<TrackNum;i++){
        for (j = 0;j<TrackNum;j++){
            if (!isVisit[j])
                distance[j] = abs(TrackOrder[j]-CurrentTrack);
            else
                distance[j] = 1000000;
        }
        pointMin = 0;
        for (j = 0;j<TrackNum;j++){
            if (distance[pointMin] > distance[j])
                pointMin = j;   
        }
        VisitOrder[i] = TrackOrder[pointMin];  
        MoveDistance[i] = abs(TrackOrder[pointMin]-CurrentTrack);  /
        SumDistance += MoveDistance[i];   
        CurrentTrack = TrackOrder[pointMin];  
        isVisit[pointMin] = true;  
    }
    AverageDistance = SumDistance*1.0/(TrackNum);
    output();
}

3.SCAN（扫描算法）
先对序列初始化，然后输入磁头移动的方向，建立新数组用来存放排序后的磁道序列。使用一个冒泡循环得出从小到大的磁道号序列。设置point，让其指向找既在当前磁道之外，又是距离最近的磁道号。如果选择增加方向，则先从point开始，第一个for循环依次遍历磁道号比point大的磁道，计算移动距离和存放位置，再将 下一个磁道号赋值给currentTrack进行下一次计算。第二个for循环从磁道号比point小的磁道开始进行相同的计算。如果选择减少的方向，则与增加方向相反。

void SCAN(){
    initial();
cout<<"SCAN"<<endl;
int i,j,temp;
    int SortTrackOrder[MaxNumber];
    cout<<"选择磁头移动的方向,1-增加,2-减少: "<<endl;
    cin>>direction;
   
    for (i = 0;i<TrackNum;i++){ 
        SortTrackOrder[i] = TrackOrder[i];
}

    for (i = 0;i<TrackNum;i++){
        for (j = i;j<TrackNum;j++){
            if (SortTrackOrder[i]>=SortTrackOrder[j]){
                temp = SortTrackOrder[i];
                SortTrackOrder[i] = SortTrackOrder[j];
                SortTrackOrder[j] = temp;
            }
        }
}
    int point = 0;
    while(StartTrack>=SortTrackOrder[point]){
        point++;
    }
 
    int count = 0;
    int currentTrack = StartTrack;
    if (direction == 1){  
        cout<<"向磁道增加的方向访问"<<endl;
        for (i = point;i<TrackNum;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
        for (i = point - 1;i>=0;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
    else if (direction == 2){  
        cout<<"向磁道减少的方向访问"<<endl;
        for (i = point-1;i>=0;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
        for (i = point;i<TrackNum;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
}

    for (i = 0;i<TrackNum;i++){
        SumDistance += MoveDistance[i];
    }
    AverageDistance = (SumDistance*1.0)/TrackNum;
    output();
}
  1. CSCAN（循环扫描SCAN算法）
    先对序列初始化，然后输入磁头移动的方向，建立新数组用来存放排序后的磁道序列。使用一个冒泡循环得出从小到大的磁道号序列。设置point，让其指向找既在当前磁道之外，又是距离最近的磁道号。如果选择增加方向，则先从point开始，第一个for循环依次遍历磁道号比point大的磁道，计算移动距离和存放位置，再将下一个磁道号赋值给currentTrack进行下一次计算。第二个for循环从最小的磁道号开始进行相同的计算。如果选择减少的方向，先从比point小一号的磁道号开始依次按磁道号减少遍历，再从磁道号最大的序列开始按磁道号减少计算。
	initial();
    cout<<"CSCAN"<<endl;
    cout<<"选择磁头移动的方向,1-增加,2-减少: "<<endl;
    cin>>direction;
 
    int SortTrackOrder[MaxNumber];
    int i,j,temp;
    for (i = 0;i<TrackNum;i++){
        SortTrackOrder[i] = TrackOrder[i];
    }
    for (i = TrackNum - 1;i>0;i--){
        for (j = 0;j<i;j++){
            if (SortTrackOrder[j]>=SortTrackOrder[j+1]){
                temp = SortTrackOrder[j];
                SortTrackOrder[j] = SortTrackOrder[j+1];
                SortTrackOrder[j+1] = temp;
            }
        }
    }
    int point = 0;
    while(StartTrack>=SortTrackOrder[point]){
        point++;
    }
 
    int count = 0;
    int currentTrack = StartTrack;
    if (direction == 1){  
        cout<<"向磁道增加的方向访问"<<endl;
        for (i = point;i<TrackNum;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
 
        for (i =0;i<point;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
    else if (direction == 2){ 
        cout<<"向磁道减少的方向访问"<<endl;
        for (i = point-1;i>=0;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
        for (i = TrackNum-1;i>point-1;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
    for (i = 0;i<TrackNum;i++){
        SumDistance += MoveDistance[i];
    }
    AverageDistance = (SumDistance*1.0)/TrackNum;
    output();
}

4.运行结果

1.程序读取data中的数据并输出，输入1执行FCFS算法。输出磁盘调度算法的模拟过程，每次移动的磁头移动距离和算法的平均寻道长度。
磁盘调度算法（操作系统实验 C＋＋）

2.输入2执行SSTF算法。输出磁盘调度算法的模拟过程，每次移动的磁头移动距离和算法的平均寻道长度
磁盘调度算法（操作系统实验 C＋＋）

3.输入3执行SCAN算法。输入1选择磁头移动方向为增加方向，输入2选择磁头移动方向为减少方向；输出磁盘调度算法的模拟过程，每次移动的磁头移动距离和算法的平均寻道长度
磁盘调度算法（操作系统实验 C＋＋）

磁盘调度算法（操作系统实验 C＋＋）

4.输入4执行CSCAN算法。输入1选择磁头移动方向为增加方向，输入2选择磁头移动方向为减少方向；输出磁盘调度算法的模拟过程，每次移动的磁头移动距离和算法的平均寻道长度

磁盘调度算法（操作系统实验 C＋＋）
磁盘调度算法（操作系统实验 C＋＋）

5.程序源码

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <stdlib.h>
using namespace std;
 
#define MaxNumber 100
int TrackOrder[MaxNumber];//初始磁道序列
int MoveDistance[MaxNumber];//磁头移动距离（磁道数）
double AverageDistance;//磁头平均移动距离
int direction;//选择磁头方向 
int TrackNum;//磁道数
int StartTrack;//开始磁道号m 
int VisitOrder[MaxNumber];//访问磁道序列
bool isVisit[MaxNumber];//标记是否被访问过
int SumDistance;//磁头移动的总距离
int choose;

void input();//输入起始磁道号、磁道顺序
void initial();
void output();
void FCFS();//先来先服务，先进先出
void SSTF();//最短寻道时间优先
void SCAN();//扫描，从开始磁道沿选择方向扫描，直到没有要访问的磁道在沿反方向扫描
void CSCAN();//循环扫描，自开始磁道始终沿一个方向扫描，直到没有要访问的磁道再从最里圈或最外圈扫描
void chooseAlgorithm();
 
int main(){
    input();
    chooseAlgorithm();
    return 0;
}
 
void input(){
    ifstream readData;
	readData.open("data.txt");
	readData>>TrackNum;  //磁道个数
	for (int i=0;i<TrackNum;i++)
	{
		readData>>TrackOrder[i];   //磁道访问序列
	}
	readData>>StartTrack;  //开始磁道号
	cout<<"磁道个数 = "<<TrackNum<<endl;
	cout<<"磁道访问序列：";
	for (int i=0;i<TrackNum;i++)
	{
		cout<<TrackOrder[i]<<" ";
	}
	cout<<endl;
	cout<<"开始磁道号m= "<<StartTrack<<endl;
	cout<<"------------------------------------"<<endl;
}
void initial(){
    for (int i=0;i<TrackNum;i++){
        MoveDistance[i] = 0;
        VisitOrder[i] = TrackOrder[i];
        isVisit[i] = false;
    }
    SumDistance = 0;
    AverageDistance = 0;
}

void output(){
    cout<<"从"<<StartTrack<<"号磁道开始"<<endl;
    cout<<"被访问的下一个磁道号"<<"\t"<<"移动距离"<<"\t"<<endl;
    for (int i=0;i<TrackNum;i++){
        cout<<VisitOrder[i]<<"\t\t\t"<<MoveDistance[i]<<"\t"<<endl;
    }
    cout<<"平均寻道长度: "<<setprecision(4)<<AverageDistance<<endl;
    cout<<endl;
}
 
//先来先服务，先进先出
void FCFS(){
    cout<<endl;
    cout<<"FCFS"<<endl;
    initial();
 
    //按照输入顺序依次访问磁道
    MoveDistance[0] = abs(TrackOrder[0]-StartTrack);
    SumDistance = MoveDistance[0];
    VisitOrder[0] = TrackOrder[0];
 
    for (int i=1;i<TrackNum;i++){
        MoveDistance[i] = abs(TrackOrder[i]-TrackOrder[i-1]);
        SumDistance += MoveDistance[i];
        VisitOrder[i] = TrackOrder[i];
    }
 
    AverageDistance = SumDistance*1.0/TrackNum;
    output();
}
 
//最短寻道时间优先
void SSTF(){
    cout<<endl;
    cout<<"SSTF"<<endl;
    initial();
    int CurrentTrack = StartTrack;
    int i,j,pointMin;
    int distance[MaxNumber];
 
    for (i = 0;i<TrackNum;i++){
        for (j = 0;j<TrackNum;j++){
            if (!isVisit[j])
                distance[j] = abs(TrackOrder[j]-CurrentTrack);
            else
                distance[j] = 10000;  //表示无穷远，即访问过的磁道就不再访问
        }
        pointMin = 0;
        for (j = 0;j<TrackNum;j++){
            if (distance[pointMin] > distance[j])
                pointMin = j;   //指向最小的位置
        }
        VisitOrder[i] = TrackOrder[pointMin];  //给访问序列赋值
        MoveDistance[i] = abs(TrackOrder[pointMin]-CurrentTrack);  //计算每次的移动距离
        SumDistance += MoveDistance[i];   //累计移动距离
        CurrentTrack = TrackOrder[pointMin];   //改变当前的磁道号
        isVisit[pointMin] = true;  //将当前的磁道号设置为已访问
    }
    AverageDistance = SumDistance*1.0/(TrackNum);
    output();
}
 
//扫描，从开始磁道沿选择方向扫描，直到没有要访问的磁道在沿反方向扫描
void SCAN(){
    cout<<endl;
    cout<<"SCAN"<<endl;
    cout<<"选择磁头移动的方向,1-增加,2-减少: "<<endl;
    cin>>direction;
    initial();
 
    int i,j,temp;
    int SortTrackOrder[MaxNumber];
    for (i = 0;i<TrackNum;i++){//初始化
        SortTrackOrder[i] = TrackOrder[i];
    }
 
    //冒泡排序
    for (i = 0;i<TrackNum;i++){
        for (j = i;j<TrackNum;j++){
            if (SortTrackOrder[i]>=SortTrackOrder[j]){
                temp = SortTrackOrder[i];
                SortTrackOrder[i] = SortTrackOrder[j];
                SortTrackOrder[j] = temp;
            }
        }
    }
 
    //找到既在当前磁道之外，又是距离最近的磁道号
    int point = 0;
    while(StartTrack>=SortTrackOrder[point]){
        point++;
    }
 
    int count = 0;
    int currentTrack = StartTrack;
 
    if (direction == 1){  //向磁道增加的方向访问
        cout<<"向磁道增加的方向访问"<<endl;
        for (i = point;i<TrackNum;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
        for (i = point - 1;i>=0;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
    else if (direction == 2){  //向磁道减少的方向访问
        cout<<"向磁道减少的方向访问"<<endl;
        for (i = point-1;i>=0;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
        for (i = point;i<TrackNum;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
    for (i = 0;i<TrackNum;i++){
        SumDistance += MoveDistance[i];
    }
    AverageDistance = (SumDistance*1.0)/TrackNum;
    output();
}
 
//循环扫描，自开始磁道始终沿一个方向扫描，直到没有要访问的磁道再从最里圈或最外圈扫描
void CSCAN(){

	initial();
    cout<<"CSCAN"<<endl;
    cout<<"选择磁头移动的方向,1-增加,2-减少: "<<endl;
    cin>>direction;
 
    
    int SortTrackOrder[MaxNumber];
    int i,j,temp;
    for (i = 0;i<TrackNum;i++){
        SortTrackOrder[i] = TrackOrder[i];
    }
  
    //冒泡排序
    for (i = TrackNum - 1;i>0;i--){
        for (j = 0;j<i;j++){
            if (SortTrackOrder[j]>=SortTrackOrder[j+1]){
                temp = SortTrackOrder[j];
                SortTrackOrder[j] = SortTrackOrder[j+1];
                SortTrackOrder[j+1] = temp;
            }
        }
    }
 
    //找到既在当前磁道之外，又是距离最近的磁道号
    int point = 0;
    while(StartTrack>=SortTrackOrder[point]){
        point++;
    }
 
    int count = 0;
    int currentTrack = StartTrack;
    if (direction == 1){  
        cout<<"向磁道增加的方向访问"<<endl;
        for (i = point;i<TrackNum;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
 
        for (i =0;i<point;i++){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
    else if (direction == 2){//向磁道减少的方向访问
        cout<<"向磁道减少的方向访问"<<endl;
        for (i = point-1;i>=0;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
        for (i = TrackNum-1;i>point-1;i--){
            VisitOrder[count] = SortTrackOrder[i];
            MoveDistance[count] = abs(VisitOrder[count]-currentTrack);
            currentTrack = VisitOrder[count];
            count++;
        }
    }
 
    for (i = 0;i<TrackNum;i++){
        SumDistance += MoveDistance[i];
    }
    AverageDistance = (SumDistance*1.0)/TrackNum;
    output();
}


void chooseAlgorithm()
{
	cout<<"请选择算法“1-FCFS，2-SSTF，3-SCAN，4-循环SCAN ,0-退出”"<<endl;
	cin>>choose;
	if (choose==1)
	{
		FCFS();
		chooseAlgorithm();
	}
		else if(choose==2)
		{
			SSTF();
			chooseAlgorithm();
		}
		else if(choose==3){
            SCAN();
        	chooseAlgorithm();
		}
		else if(choose==4){
            CSCAN();
            chooseAlgorithm();
		}
		else if(choose==0){
          exit(0);
		}
	else
	{
		cout<<"请输入正确的选择“1-FCFS，2-SSTF，3-SCAN，4-循环SCAN ,0-退出”"<<endl;
		chooseAlgorithm();  
	}
}

输入数据格式文章来源地址https://www.toymoban.com/news/detail-471840.html

10
78 30 9 15 102 140 156 54 45 125
100

到了这里，关于磁盘调度算法（操作系统实验 C＋＋）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 操作系统：实验一：进程调度实验——最高优先数优先的调度算法以及先来先服务算法 源码

    操作系统：实验一：进程调度实验——最高优先数优先的调度算法以及先来先服务算法 源码

    一、实验目的 （1）了解进程实体PCB结构； （2）理解进程不同状态和状态之间的转换过程； （3）掌握优先数的调度算法和先来先服务算法； 二、实验内容与要求 设计一个有 N个进程共行的进程调度程序 四、实验步骤 （1）实验设计 进程调度算法： 采用最高优先数优先的调

    2024年02月06日
    浏览(30)

  • 计算机操作系统实验-进程调度模拟算法

    进程调度是处理机管理的核心内容。本实验要求用高级语言编写模拟进程调度程序，以 便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法 的具体实施办法。 1.设计进程控制块 PCB 的结构，通常应包括如下信息： 进程名、进程优先数（

    2024年02月05日
    浏览(44)
  • 操作系统实验——处理机调度算法(C语言）

    操作系统实验——处理机调度算法(C语言）

    目录 实验要求 代码实现 运行结果 代码解析   1、设定系统中进程数，每一个进程用一个进程控制块表示。 2、输入每个进程的“优先数”和“要求运行时间”。 3、为了调度方便，将进程按给定的优先数从大到小连成就绪队列。用一单元指出队列首进程 4、处理机调度总是选

    2023年04月27日
    浏览(31)
  • 先来先服务调度算法（C语言代码实现） 大三操作系统实验

    先来先服务调度算法（C语言代码实现） 大三操作系统实验

    实验原理: 先来先服务（First Come First Served,FCFS），是一种简单的调度算法，它既适用于作业调度，也适用于进程调度。先来先服务算法是按照作业或进程的到达先后次序来进行调度。当作业调度中采用该算法时，每次调度都是从后备队列中选择一个最先进入该队列中作业，将

    2024年04月16日
    浏览(23)
  • 实现时间片轮转算法（模拟）计算机操作系统实验5：进程调度算法模拟-RR

    实现时间片轮转算法（模拟）计算机操作系统实验5：进程调度算法模拟-RR

    实验内容： 实现时间片轮转算法（模拟），要求如下： 1、用到的数据结构 /* PCB / struct PCB { pid_t pid;//进程 PID int state; //状态信息，1 表示正在运行，0 表示暂停,-1 表示结束 unsigned long runned_time;//已运行时间 unsigned long need_running_time;//剩余运行时间 }; / PCB集合 */ struct PCB pcb[TOT

    2024年02月04日
    浏览(44)
  • 操作系统实验一模拟优先级调度算法（C语言实现附带详细注释）

    操作系统实验一模拟优先级调度算法（C语言实现附带详细注释）

    文章目录 优先级调度算法介绍 两种情况 调度算法分类 优先级分类 实验内容与要求 实验步骤 调度算法总流程图  优先级调度算法流程图  实验代码 实验结果         优先级调度算法既可以用于作业调度，又可以用于进程调度。该算法中的优先级用于描述作业或者进程的

    2024年02月01日
    浏览(36)
  • 操作系统实验（进程调度）

    操作系统实验（进程调度）

      1.1理解有关进程控制块、进程队列的概念。   1.2掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。   2.1设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。   2.2建立进程就绪队列。   2.3编制两种进程调度算法：优先权调度

    2024年02月06日
    浏览(35)
  • 操作系统-进程调度实验报告

    操作系统-进程调度实验报告

    1．实现四种不同及进程调度算法： 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 2．通过实验理解有关进程控制块，进程队列等的概念。 1.运行素材中的代码，观察其执行结果是否正确？各个调度算法的功能是否完善？如果没有，则完善。 2. 按照下表

    2024年02月06日
    浏览(31)
  • 计算机操作系统实验：进程调度实验

    计算机操作系统实验：进程调度实验

    前言 二、实验目的 三、实验要求 四、实验原理 五、实验过程 六、代码详解 总结 计算机操作系统是管理计算机硬件和软件资源的核心软件，它负责为用户提供一个友好、高效、安全的使用环境。进程调度是操作系统的一个重要功能，它决定了进程在处理器上的执行顺序和时

    2024年02月07日
    浏览(39)
  • 【操作系统实验6】CPU调度程序模拟实现

    【操作系统实验6】CPU调度程序模拟实现

    加深对操作系统CPU调度以及调度算法的理解 1） 单处理器环境下，针对最短作业优先算法(SJF)和优先级调度算法(Priority)，分别模拟实现抢占调度和非抢占调度的调度程序 设计使用三个队列，分别为就绪队列(readyQueue)、运行队列(runningQueue)、等待队列(waitingQueue) 进程状态三种，

    2024年02月06日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包