操作系统四种调度算法

最新推荐文章于 2024-05-30 06:45:00 发布
最新推荐文章于 2024-05-30 06:45:00 发布
阅读量4k 收藏 53
点赞数 9
分类专栏： 操作系统 文章标签： 作业调度 进程调度 优先调度算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38177302/article/details/88932759
版权

一、 实验目的：
1、掌握进程调度的任务、机制和方式。
2、熟练掌握进程进程调度的算法的原理。
二、实验内容：
1、 实现 短作业优先调度算法
2、 实现 先到先服务调度算法
3、 实现 非抢占式高响应比优先调度算法
4、 实现 抢占式高响应比优先调度算法
三、实验代码
实验全部代码见附件code.txt
实验的主要代码如下：
//进程结构体
struct Task
{
char name[10]; // 进程名称
int come_time; // 到达时间
int turn_time; // 运行时间
int start_time; // 开始运行时间
int end_time;// 结束运行时间
int wait_time; // 等待时间
}task[N], tp_task[N];

//短作业优先算法
void SJF()
{
/**
功能：实现短作业优先算法，将进程的运行结束信息
按照进程运行顺序输出。
*/

sort(task, task+num, cmp1);
int countt = 0;
for (int i = 0; i < num; i++)
{
    printf("%s进程正在执行", task[i].name);
    for (int j = 0; j < 10; j++)
    {
        sleep(100 * task[i].turn_time); printf(".");
    }
    putchar('\n');

    //sleep(1000 * task[i].turn_time);  // 程序暂停时间（单位：ms)
    task[i].start_time = countt;
    countt += task[i].turn_time;
    task[i].end_time = countt;
}
printf("\n所有进程全部执行完毕！！！\n\n");

Print();

}

//先来先服务算法
void FCFS()
{
/**
功能：实现先来先服务算法，将进程的运行结束信息
按照进程运行顺序输出。
*/

int countt = 0;
sort(task, task+num, cmp2);

for (int i = 0; i < num; i++)
{
    printf("%s进程正在执行", task[i].name);
    for (int j = 0; j < 10; j++)
    {
        sleep(100 * task[i].turn_time); printf(".");
    }
    putchar('\n');

    //sleep(1000 * task[i].turn_time);  // 程序暂停时间（单位：ms)
    task[i].start_time = countt;
    countt += task[i].turn_time;
    task[i].end_time = countt;
}
printf("\n所有进程全部执行完毕！！！\n\n");

Print();

}

// 非抢占 高响应比 优先调度算法
void HRRN()
{
/**
功能；运行非抢占式 高响应比 优先调度算法执行进程，将进程的运行结束信息
输出显示。
*/
//初始化进程的结束时间 -1
for (int i = 0; i < num; i++)
task[i].end_time = -1;

int countt = 0;  //计时器
while (true)
{
    for (int i = 0; i < num; i++)
        task[i].wait_time = countt - task[i].come_time;
    sort(task, task + num, cmp3);

    if (task[0].end_time >= 0) break;

    printf("%s进程正在执行", task[0].name);
    for (int j = 0; j < 10; j++)
    {
        sleep(100 * task[0].turn_time); printf(".");
    }
    putchar('\n');

    //sleep(1000 * task[0].turn_time);  // 程序暂停时间（单位：ms)
    task[0].start_time = countt;
    countt += task[0].turn_time;
    task[0].end_time = countt;
}
printf("\n所有进程全部执行完毕！！！\n\n");

sort(task, task + num, cmp4); // 按照开始运行的时间从小到大排序
Print();

}

// 抢占式 高响应比 优先调度算法
void PreemptiveHRRN()
{
/**
功能；运行抢占式 高响应比 优先调度算法执行进程，将进程的运行结束信息
输出显示。
*/

//备份每个进程的服务时间
map<string, int> shift;
shift.clear();

for (int i = 0; i < num; i++)
    shift[ task[i].name ] = task[i].turn_time;


//初始化进程的结束时间 and 进程的开始运行时间  -》 -1
for (int i = 0; i < num; i++)
    task[i].end_time = task[i].start_time = -1;

int countt = 0;  //计时器
while (true)
{
    for (int i = 0; i < num; i++)
        task[i].wait_time = countt - task[i].come_time;
    sort(task, task + num, cmp3);

    if (task[0].end_time >= 0) break;


    if (task[0].start_time < 0)
        task[0].start_time = countt;

    printf("%s进程正在执行", task[0].name);
    for (int j = 0; j < 10; j++)
    {
        sleep(100); printf(".");
    }
    putchar('\n');

    //sleep(1000);  // 程序暂停时间（单位：ms)
    countt++;     //运行一个时间片  （1 s)
    task[0].turn_time--;

    if (task[0].turn_time <= 0 && task[0].end_time < 0)
        task[0].end_time = countt;
}
printf("所有进程全部执行完毕！！！\n\n");

//恢复每个进程的服务时间
for (int i = 0; i < num; i++)
    task[i].turn_time = shift[task[i].name];

sort(task, task + num, cmp5); // 按照开始运行的时间从小到大排序
Print();

}

四、实验结果
实验测试数据如下：
5
A 0 9
B 1 3
C 2 8
D 3 2
E 4 5
数据输入：

（1） 短作业优先调度算法

（2） 先到先服务调度算法

（3） 非抢占式高响应比优先调度算法

（4） 抢占式高响应比优先调度算法

五、实验总结
本次实验的内容为实现了四中进程调度的算法：短作业调度算法、先来先服务进程调度算法、非抢占试高响应比优先调度算法、抢占式高响应比优先调度算法。通过对四中进程调度算法的实现，熟练地掌握了调度算法的原理，同时也对操作系统当中关于调度方面的内容有了更加深刻的了解。在算法实现方面，觉得自己构建的那个结构体里面的变量有些不足之处，例如进程相关的时间可能不是整数，而我却为了简化操作，用了整型来表示和进程相关的时间信息

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <ctime>
#include <map>
using namespace std;


const int N = 1000;
struct Task
{
    char name[10]; // 进程名称
    int come_time; // 到达时间
    int turn_time; // 运行时间
    int start_time; // 开始运行时间
    int end_time;// 结束运行时间
    int wait_time; // 等待时间
}task[N], tp_task[N];

int num;//进程数目

void sleep(int n)
{
    int st = clock();
    while ((clock() - st) <= n);
}

void GetData()
{
    printf("请输入每个进程的名称，到达时间，服务时间\n");
    for (int i = 0; i < num; i++)
    {
        printf("第%d个进程信息输入：\n",i+1);
        scanf("%s%d%d", task[i].name, &task[i].come_time, &task[i].turn_time);
        strcpy(tp_task[i].name, task[i].name);
        tp_task[i].come_time = task[i].come_time;
        tp_task[i].turn_time = task[i].turn_time;
    }
    printf("进程信息输入完毕！！！\n");
}

void BackData()
{
    for (int i = 0; i < num; i++)
    {
        strcpy(task[i].name, tp_task[i].name);
        task[i].come_time = tp_task[i].come_time;
        task[i].turn_time = tp_task[i].turn_time;
    }
    printf("进程信息还原成功！！！\n");
}

void Print()
{
    printf("进程运行信息：\n");
    printf("task_name  come_time   start_time   turn_time   end_time\n");
    for (int i = 0; i < num; i++)
    {
        printf("     %-9s%-13d", task[i].name, task[i].come_time);
        printf("%-10d%-12d", task[i].start_time, task[i].turn_time);
        printf("%-4d\n", task[i].end_time);
    }
}

bool cmp1(const struct Task &a, const struct Task &b)
{
    return a.turn_time < b.turn_time;
}

//短作业优先算法
void SJF()
{
    /**
    功能：实现短作业优先算法，将进程的运行结束信息
          按照进程运行顺序输出。
    */

    sort(task, task+num, cmp1);
    int countt = 0;
    for (int i = 0; i < num; i++)
    {
        printf("%s进程正在执行", task[i].name);
        for (int j = 0; j < 10; j++)
        {
            sleep(100 * task[i].turn_time); printf(".");
        }
        putchar('\n');

        //sleep(1000 * task[i].turn_time);  // 程序暂停时间（单位：ms)
        task[i].start_time = countt;
        countt += task[i].turn_time;
        task[i].end_time = countt;
    }
    printf("\n所有进程全部执行完毕！！！\n\n");

    Print();
}

bool cmp2(const struct Task &a, const struct Task &b)
{
    return a.come_time < b.come_time;
}

//先来先服务算法
void FCFS()
{
    /**
    功能：实现先来先服务算法，将进程的运行结束信息
          按照进程运行顺序输出。
    */

    int countt = 0;
    sort(task, task+num, cmp2);

    for (int i = 0; i < num; i++)
    {
        printf("%s进程正在执行", task[i].name);
        for (int j = 0; j < 10; j++)
        {
            sleep(100 * task[i].turn_time); printf(".");
        }
        putchar('\n');

        //sleep(1000 * task[i].turn_time);  // 程序暂停时间（单位：ms)
        task[i].start_time = countt;
        countt += task[i].turn_time;
        task[i].end_time = countt;
    }
    printf("\n所有进程全部执行完毕！！！\n\n");

    Print();
}


bool cmp3(const struct Task &a, const struct Task &b)
{
    if (a.end_time < 0 && b.end_time < 0)
    {
        double ra = (a.wait_time + a.turn_time)*1.0 / a.turn_time;
        double rb = (b.wait_time + b.turn_time)*1.0 / b.turn_time;
        return ra > rb;
    }
    else
        return a.end_time < b.end_time;
}

bool cmp4(const struct Task &a, const struct Task &b)
{
    return a.come_time < b.come_time;
}

// 非抢占 高响应比 优先调度算法
void HRRN()
{
    /**
    功能；运行非抢占式 高响应比 优先调度算法执行进程，将进程的运行结束信息
          输出显示。
    */
    //初始化进程的结束时间 -1
    for (int i = 0; i < num; i++)
        task[i].end_time = -1;

    int countt = 0;  //计时器
    while (true)
    {
        for (int i = 0; i < num; i++)
            task[i].wait_time = countt - task[i].come_time;
        sort(task, task + num, cmp3);

        if (task[0].end_time >= 0) break;

        printf("%s进程正在执行", task[0].name);
        for (int j = 0; j < 10; j++)
        {
            sleep(100 * task[0].turn_time); printf(".");
        }
        putchar('\n');

        //sleep(1000 * task[0].turn_time);  // 程序暂停时间（单位：ms)
        task[0].start_time = countt;
        countt += task[0].turn_time;
        task[0].end_time = countt;
    }
    printf("\n所有进程全部执行完毕！！！\n\n");

    sort(task, task + num, cmp4); // 按照开始运行的时间从小到大排序
    Print();
}

bool cmp5(const struct Task a, const struct Task b)
{
    return a.end_time < b.end_time;
}

// 抢占式 高响应比 优先调度算法
void PreemptiveHRRN()
{
    /**
    功能；运行抢占式 高响应比 优先调度算法执行进程，将进程的运行结束信息
          输出显示。
    */

    //备份每个进程的服务时间
    map<string, int> shift;
    shift.clear();

    for (int i = 0; i < num; i++)
        shift[ task[i].name ] = task[i].turn_time;


    //初始化进程的结束时间 and 进程的开始运行时间  -》 -1
    for (int i = 0; i < num; i++)
        task[i].end_time = task[i].start_time = -1;

    int countt = 0;  //计时器
    while (true)
    {
        for (int i = 0; i < num; i++)
            task[i].wait_time = countt - task[i].come_time;
        sort(task, task + num, cmp3);

        if (task[0].end_time >= 0) break;


        if (task[0].start_time < 0)
            task[0].start_time = countt;

        printf("%s进程正在执行", task[0].name);
        for (int j = 0; j < 10; j++)
        {
            sleep(100); printf(".");
        }
        putchar('\n');

        //sleep(1000);  // 程序暂停时间（单位：ms)
        countt++;     //运行一个时间片  （1 s)
        task[0].turn_time--;

        if (task[0].turn_time <= 0 && task[0].end_time < 0)
            task[0].end_time = countt;
    }
    printf("所有进程全部执行完毕！！！\n\n");

    //恢复每个进程的服务时间
    for (int i = 0; i < num; i++)
        task[i].turn_time = shift[task[i].name];

    sort(task, task + num, cmp5); // 按照开始运行的时间从小到大排序
    Print();
}

void Menu()
{
    printf("             命令\n");
    printf("\n\n       **** 0.输入进程数据信息\n");
    printf("       **** 1.FCFS算法\n");
    printf("       **** 2.SJF算法\n");
    printf("       **** 3.HRRN算法\n");
    printf("       **** 4.PreemptiveHRRN算法\n");
    printf("       **** 5.End Up Code!!!\n\n");
}

int main()
{
    int menu;
    int flag = 1;
    printf("             《进程调度实验程序》\n\n");
    while (flag)
    {
        Menu();
        printf("请输入命令: ");
        cin >> menu;
        switch (menu)
        {
            case 0:
                printf("请输入进程的个数:  ");
                scanf("%d", &num);
                GetData();
                break;
            case 1:
                printf("     <启动 FCFS 调度算法>\n");
                FCFS();
                break;
            case 2:
                printf("     <启动 SJF 调度算法>\n");
                SJF();
                break;
            case 3:
                printf("     <启动非抢占式 HRRN 调度算法>\n");
                HRRN();
                break;
            case 4:
                printf("     <启动抢占式 HRRN 调度算法>\n");
                PreemptiveHRRN();
                break;
            case 5:
                flag = 0;
                break;

        }
        BackData();
    }



    return 0;
}
枸杞柠檬茶
关注
  • 9
    点赞
  • 踩
  • 53
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
操作系统--进程调度算法
weixin_44057997的博客
01-28 733
一、要求 （1）先来先服务算法，短进程优先算法，高优先级优先算法，时间片轮转调度算法； （2）有录入界面，动态录入进程个数，进程标识符，进入时间，服务时间，优先级，系统时间片长短等信息； （3）有算法选择界面，能够选择不同的调度算法； （4）有输出界面，输出不同调度算法下诸进程的进程标识符，进入时间，服务时间，开始时间，完成时间，周转时间，带权周转时间及一组进程的平均周转时间及平均带权周转时间。 二、原理 定义一个进程控制块PCB，包含进程标识符，进入时间，服务时间，开始时间，完成时间，周转时间，带权周转时
操作系统-第四次实验
qq_45755193的博客
12-10 512
进程调度算法 实现先到先服务调度算法（FCFS） 实现时间片轮转调度算法（RR）
操作系统实验 - 题目二 进程调度算法的实现
qq_40580037的博客
09-06 4493
2．1 题目的主要研究内容及预期达到的目标 【设计目的】 理解进程调度相关理论；掌握时间片调度原理；掌握高优先级调度原理 【课题描述】 本课题主要针对操作系统中进程调度相关理论进行设计。要求编写程序并进行测试，该程序可以对多个进程进行调度，调度算法采用基于时间片的高优先级调度。 【课题内容】 （1）设计进程控制块； （2）设计多个进程队列； （3）设计多个进程（≥20）； （4）动态生成时间片、执行时间和优先级，将这些信息输出至文件中； （5）设计基于时间片的多优先级调度算法； （6）动态调度，并把所有调度
操作系统之CPU调度算法——FCFS、SJF和SRTF
最新发布
PleaSure乐事的博客
05-30 1348
对CPU调度算法中FCFS、SJF和SRTF的一些解释
操作系统设计（包含作业调度算法源代码和实验报告）
07-21
操作系统实验（作业调度算法源代码），包含3种算法：先来先服务、最高响应比和短作业优先，包含实验报告。
实验：进程调度算法(C语言)
qq_44833321的博客
02-17 1万+
实验：进程调度算法 一、实验目的 1．实现四种不同及进程调度算法： 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 2．通过实验理解有关进程控制块，进程队列等的概念。 二、实验要求 1.运行素材中的代码，观察其执行结果是否正确？各个调度算法的功能是否完善？如果没有，则完善。 2. 按照下表输入3个作业信息，输出使用不同调度算法的结果。 3. 在现有三个调度算法的基础上，进一步实现短作业优先调度 ProcessID arrivetime servicetime priority
【操作系统】抢占与非抢占式调度
Naomi的博客
10-15 3443
最佳适合算法产生的内存碎片要比最先适合算法多，因为将小而不能使用的碎片放在自由表开头部分的排序趋势更为强烈 抢占式调度（Preemptive Scheduling）是一种CPU调度技术，它通过将CPU的时隙划分给给定的进程来工作。给定的时间间隔可能能够完成整个过程，也可能无法完成。当进程的区间时间（burst time）大于CPU周期时，它将被放回到就绪队列（ready queue）中，并在下一个时机（chance）执行。当进程切换到就绪状态时，会使用这种调度方式。 抢占式调度支持的算法有循环调度(RR)、
操作系统磁盘调度算法实验报告
05-07
操作系统磁盘调度算法实验报告 本实验报告的主要目的是设计一个磁盘调度模拟系统，旨在使磁盘调度算法更加形象化、易于理解，使磁盘调度的特点更简单明了。通过本实验，学生可以加深对先来先服务算法、最短寻道时间...
操作系统磁盘调度算法及模拟实验三
01-06
"操作系统磁盘调度算法及模拟实验三" 磁盘调度算法是操作系统中的一种重要算法，它决定了操作系统如何管理磁盘I/O请求，以提高磁盘的读写性能。磁盘调度算法的选择对系统的性能和效率产生了极大的影响。 磁盘调度...
操作系统课程设计磁盘调度算法.doc
06-16
操作系统课程设计磁盘调度算法是计算机操作系统中的一种重要算法，用于确定磁盘读写操作的顺序，以提高磁盘的读写效率。本文将对磁盘调度算法的设计进行详细的介绍，并对其实现过程进行剖析。 1. 操作系统课程设计...
进程调度算法包括先来先服务调度算法、最短作业时间优先（抢占式和非抢占式）、最高响应比调度算法4种
04-11
1. 实验目的 调度的实质是操作系统按照某种预定的策略来分配资源。进程调度的目的是分配CPU资源。由于进程调度程序执行的频率很高，因此调度算法的好坏直接影响到操作系统的性能。本实验的目的是编程模拟实现几种常用的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。 2. 实验原理 [1]. 进程调度算法描述 进程调度算法包括先来先服务调度算法、最短作业时间优先（抢占式和非抢占式）、最高响应比调度算法4种。(每个人必须做FCFS，然后在后面的三种中任选一种，即每个人必须做2种调度算法的模拟。) [2]. 衡量算法性能的参数 计算进程的平均周转时间和平均带权周转时间。 3. 实验内容 （1）编程实现本实验的程序，要求： [1]. 建立进程的进程控制块，进程控制块至少包括： a) 进程名称； b) 进程需要执行时间； c) 进入就绪队列时间； d) 进程执行开始时间 e) 进程执行结束时间 [2]. 编程实现调度算法。 [3]. 进程及相关信息的输入。这些信息可以直接从键盘上输入，也可以从文件读取。 [4]. 时间片与时间流逝的模拟。本实验需要对算法的执行计时，程序应该提供计算时间的方法。一种最简单的方法是使用键盘，比如每敲一次空格代表一个时间片的流逝。另一种方法是使用系统时钟。 [5]. 一组进程序列执行完毕，打印出结果信息。程序需要计算出每个进程的开始执行时间、结束时间、周转时间和带权周转时间，并为整个进程序列计算平均周转时间和平均带权周转时间。程序将计算结果按一定的格式显示在计算机屏幕上或输出到文件中。打印出进程调度顺序图。 [6]. 实现数据在磁盘文件上的存取功能。 （2）对下列就绪进程序列分别使用上面的几种算法进行调度，计算每种算法下的平均周转时间和平均带权周转时间。 进程号 到达时间 要求执行时间 0 0 1 1 1 35 2 2 10 3 3 5 4 6 9 5 7 21 6 9 35 7 11 23 8 12 42 9 13 1 10 14 7 11 20 5 12 23 3 13 24 22 14 25 31
操作系统电梯调度算法c语言实现
03-22
假设要求从系统中输入N个需访问的柱面号，当前磁头的移动方向由键盘输入(1代表磁头从外往内移动，-1代表磁头由内往外移动)，当前磁头刚完成访问序号为M的柱面，请编程输出采用电梯调度算法得到的柱面访问序列号，...
「 操作系统 」聊聊进程调度算法
frozenpenguin的博客
04-08 4506
进程调度算法是操作系统中非常重要的一部分，它决定了操作系统中各个进程的执行顺序和时间片。在单核CPU下，任何时刻都只可能有一个程序在执行，比如正在计算1*2这个程序A，那么就不能运行1+…+n这个求和程序B，这个时候程序A处于执行状态，而程序B处于非执行状态。我们在任意时刻到底是执行哪个程序呢？我们运行的地铁列车，有指挥中心统一控制调度，到底由哪些地铁执行哪一天的任务，这是因为轨道等资源有限，不可能全放进去。类似到进程调度，CPU等硬件资源有限，也不可能全部一起执行。这就引出了我们的进程调度。
作业与作业调度--四种调度算法
princekin_even的博客
10-21 6920
当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是最优先考虑在系统中等待时间最长的作业，不管作业执行时间的长短。在进程调度中，采用FCFS算法时，每次调度就是从就绪队列中选择最先进入该队列的进程，为其分配处理机，运行。响应比 = （作业等待时间 + 作业运行时间）/ 作业运行时间 = 1 + 作业等待时间 / 作业运行时间。基于作业紧迫程度，赋予作业响应的优先级，系统从后备队列获取优先级高的进程优先执行。优先级动态变化，既可以考虑到作业进入系统的次序，又能考虑到作业运行的时间。
进程调度算法；先来先服务调度算法、短作业优先调度算法、时间片轮转调度算法
再走一步
06-20 3万+
一、 实验目的和要求1. 了解进程调度算法的特点2. 掌握进程调度算法，如先来先服务调度算法（first come first served,FCFS）、短作业优先调度算法（shotjob first,SJF）、时间片轮转调度算法。二、实验内容设计模拟实现FCFS、SJF、时间片轮转调度算法的C语言程序1. FCFS算法：按照作业/进程进入队列的先后顺序进行挑选，先进入的将先进行...
C语言 操作系统实验 四种调度（时间片轮转法 RR）
key_149的博客
11-09 3293
注： 本文是四个调度算法的第一篇算法。 本文是根据CSDN上某一FCFS调度算法魔改来的，所以FCFS的算法不会发到网站。 我是个菜鸡，发文是为了纪念自己完成了代码，以及累计自己的经验。 如有知识错误或者算法有逻辑漏洞请各位大佬高抬贵手。 实验环境：win10、VS2019（C++） PS：虽然是cpp文件，实际上是披着cpp的c 运行前，首先要在预处理器上插入_CRT_SECURE_NO_WARNINGS，避免运行错误，在插入前要用;隔开。 具体位置就在解...
常用的进程调度算法
越陌度阡
12-14 6183
进程调度是由操作系统的进程调度程序按照某种策略和算法从就绪态进程中为当前空闲的CPU选择要运⾏的新进程，常用的进程调度算法有以下几种： 1. 先来先服务调度算法 从就绪队列的队⾸选择最先到达的进程，为该进程分配CPU。下面通过一个例子来说明先来先服务算法。 已知：就续队列中有3个进程， 分别为P1、P2、P3，进入系统的时间分别为0、1、2，服务时间分别为24、3、3，求3个进程的系统......
【操作系统 - 1】先来先服务FCFS和短作业优先SJF进程调度算法
热门推荐
Houchaoqun_XMU的博客
03-17 6万+
【操作系统系列】学习至此，发现很多学了但很久没用的知识，久而久之，慢慢遗忘。等哪天还需要的话，却发现已经忘得差不多了，即使整理了文档（word等），还是得从头再学一遍。读研第一学期，发现很多东西都可以从博客上学习到，也有不少博主呕心沥血整理了挺多有用的博文。于是，本人借此契机，也慢慢开始整理一些博文，不断改进完善中。整理博文（IT）有如下目的。1. 首要目的：记录“求学生涯”的所学所悟，不断修改，不断更新！（有读者的互动）2. 其次目的：在这“开源”的时代，整理并分享所学所悟是一种互利的行为。
操作系统磁盘调度算法设计任务书
操作系统磁盘调度算法是计算机系统中的重要组成部分，它负责合理地安排磁盘上的数据访问顺序，以提高系统的读写效率。磁盘调度算法的设计旨在减少磁头移动次数，减小磁盘寻道时间，从而提高磁盘的数据访问速度。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值