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

操作系统有关进程调度算法（含先来先服务，短作业优先，优先级调度算法和时间片轮转调度算法）

10月前 作者：倦鸟馀生 分类：Toy博客 阅读(60) 违法举报

这篇具有很好参考价值的文章主要介绍了操作系统有关进程调度算法（含先来先服务，短作业优先，优先级调度算法和时间片轮转调度算法）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言：

本文采用的进程调度算法有：先来先服务，短作业优先，优先级调度算法和时间片轮转调度算法。

针对这四种算法，我采用的是建立数组结构体，如：

struct job {
    char name[10];      //作业的名字
    int starttime;      //作业到达系统时间
    int needtime;       //作业服务时间
    int runtime;        //作业周转时间
    int endtime;        //作业结束时间
    double dqzz_time;    //带权周转时间
};

一，先来先服务算法：

1，算法思想：

先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。采用FCFS算法，每次从后备队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为他们分配资源，创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

2，算法实例：

首先，先对运行函数进行声明：

void FCFS(struct job jobs[50], int n);//先来先服务算法

其中n为进程个数。

其次，按照进程到达时间进行排序：

for (i = 0; i < n; i++) //按作业到达系统时间进行排序，最早到达的排在最前面 
    {
        for (j = i; j < n; j++) //按作业到达系统时间进行排序，最早到达的排在最前面 
        {
            if (jobs[j].starttime < jobs[i].starttime)
            {   //把到达时间早的赋值到t_time
                t_time = jobs[j].starttime;
                jobs[j].starttime = jobs[i].starttime;
                jobs[i].starttime = t_time;
                //把到达时间早的赋值到t_time
                t_time = jobs[j].needtime;
                jobs[j].needtime = jobs[i].needtime;
                jobs[i].needtime = t_time;
                strcpy(t_name, jobs[j].name);//这里用strcpy函数是由于name变量为字符串类型，不能用=赋值
                strcpy(jobs[j].name, jobs[i].name);
                strcpy(jobs[i].name, t_name);//利用t_name数组进行交换排序
            }
        }
    }

二，短作业优先算法

1，算法思想:

短作业优先（SJF, Shortest Job First）又称为“短进程优先”SPN(Shortest Process Next)；是对FCFS算法的改进，其目标是减少平均周转时间。

短作业优先调度算法基于这样一种思想：

运行时间短的优先调度；

如果运行时间相同则调度最先发起请求的进程。

等待时间：一个进程从发起请求到开始执行的时间间隔。

现在有n个进程请求cpu，每个进程用一个二元组表示：(p,q),p代表该进程发起请求的时间，p代表需要占用cpu的时间。

请计算n个进程的平均等待时间。

2，算法实例：

首先，先对运行函数进行声明：

void SJF(struct job jobs[50], int n);//短作业优先算法

其中n为进程个数。

其次，按照最短运行时间排序：

for (i = 1; i < n; i++)
    {
        for (j = i; j < n; j++)
        {
            //按最短运行时间排序
            //关于jobs[i - 1].endtime > jobs[j].starttime如果到达时间太迟于上一轮的结束时间，会造成浪费时间资源用以等待
            if (jobs[i - 1].endtime > jobs[j].starttime && jobs[j].needtime < jobs[i].needtime)
            {
                t_time = jobs[i].starttime;
                jobs[i].starttime = jobs[j].starttime;
                jobs[j].starttime = t_time;
                //把短的赋值到临时变量t_time中
                t_time = jobs[i].needtime;
                jobs[i].needtime = jobs[j].needtime;
                jobs[j].needtime = t_time;
                strcpy(t_name, jobs[i].name);   //将第二个参数的值复制给第一个参数，返回第一个参数
                strcpy(jobs[i].name, jobs[j].name);
                strcpy(jobs[j].name, t_name);
            }                 //按最短运行时间排序
        }
        if (jobs[i].starttime > jobs[i - 1].endtime)
        {       //第i个进程到达系统时，第i-1个进程已运行完毕
            jobs[i].endtime = jobs[i].starttime + jobs[i].needtime;//结束时间=到达时间+服务时间
            jobs[i].runtime = jobs[i].needtime;//周转时间=服务时间
        }
        else
        {
            jobs[i].endtime = jobs[i - 1].endtime + jobs[i].needtime;//结束时间=上一个的结束时间+服务时间
            jobs[i].runtime = jobs[i].endtime - jobs[i].starttime;//周转时间=结束时间-到达时间
        }
        jobs[i].dqzz_time = jobs[i].runtime * 1.0 / jobs[i].needtime;
    }

三，优先级调度算法

1，算法思想：

优先级调度的含义

当该算法用于作业调度时，系统从后备作业队列中选择若干个优先级最高的，且系统能满足资源要求的作业装入内存运行。

当该算法用于进程调度时，将把处理机分配给就绪进程队列中优先级最高的进程。

调度算法的两种方式

优先级调度算法细分成如下两种方式：

非抢占式优先级算法

在这种调度方式下，系统一旦把处理机分配给就绪队列中优先级最高的进程后，该进程就能一直执行下去，直至完成；或因等待某事件的发生使该进程不得不放弃处理机时，系统才能将处理机分配给另一个优先级高的就绪进程。

抢占式优先级调度算法

在这种调度方式下，进程调度程序把处理机分配给当时优先级最高的就绪进程，使之执行。一旦出现了另一个优先级更高的就绪进程时，进程调度程序就停止正在执行的进程，将处理机分配给新出现的优先级最高的就绪进程。

优先级的类型

进程的优先级可采用静态优先级和动态优先级两种，优先级可由用户自定或由系统确定。

2，算法实例：

首先，先对运行函数进行声明：

void HRRN(struct job jobs[50],int n);//优先调度算法

其中n为进程个数。

其次，设计优先级：

double hrrn[10];//动态优先级

然后，按照优先级进行比较并排序：

for (i = 1; i < n; i++) 
    {
        for (j = i; j < n; j++) 
        {
            //优先级=（等待时间+要求服务时间）/ 要求服务时间
            hrrn[j] = static_cast<double>(jobs[i - 1].endtime - jobs[j].starttime + jobs[j].needtime) / jobs[j].needtime;
        }//这是此时第i个进程结束后的所有进程的优先级
        for (int t = i + 1; t < n; t++) {
            if (hrrn[t] > hrrn[i]) {
                t_time = jobs[t].starttime;
                jobs[t].starttime = jobs[i].starttime;
                jobs[i].starttime = t_time;
                //把短的赋值到临时变量t_time中
                t_time = jobs[t].needtime;
                jobs[t].needtime = jobs[i].needtime;
                jobs[i].needtime = t_time;
                strcpy(t_name, jobs[t].name);
                strcpy(jobs[t].name, jobs[i].name);
                strcpy(jobs[i].name, t_name);
            }//按优先级进行比较并排序
        }
        jobs[i].endtime = jobs[i - 1].endtime + jobs[i].needtime;//第i个进程的结束时间=上一个的结束时间+服务时间
    }

四，时间片轮转调度算法

1，算法思想：

时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法。每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表，当进程用完它的时间片后，它被移到队列的末尾。

2，算法实例：

首先，先对运行函数进行声明：

void RR(struct job jobs[50],int n);//时间片轮转算法

其中n为进程个数。

其次，以scanf函数从键盘得到一个时间片长度：

printf("请输入时间片的大小：");
    scanf("%d",&t);

 这里由于我用以运行结果显示方便，因此直接用周转时间和带权周转时间的结果表示：

for (i = 0; i < n; i++) {
        s += jobs[i].needtime;//s是用来确认所有进程全部结束
        f[i] = jobs[i].needtime;//f[i]用以存储单个进程剩余所需运行时间
    }
    do {
        for (i = 0; i < n; i++) {
            if (f[i]) {         //若f[i] == 0，则说明本进程的运行已全部结束
                //如果本进程剩余时间比时间片大，则总运行时间加一个时间片，本进程剩余运行时间减一个时间片，并将s减一个时间片
                if (f[i] > t) { 
                    time += t;
                    f[i] -= t;
                    s -= t;
                }
                //如果本进程剩余时间比时间片小，则总运行时间加一个时间片，s减一个本进程剩余运行时间，并将本进程剩余运行时间归零
                else {
                    time += t;
                    jobs[i].endtime = time;
                    s -= f[i];
                    f[i] = 0;
                }
            }
        }
    } while (s);
    for (i = 0; i < n; i++) {
        jobs[i].runtime = jobs[i].endtime - jobs[i].starttime;//周转时间 = 结束时间 - 到达时间
        jobs[i].dqzz_time = jobs[i].runtime * 1.0 / jobs[i].needtime;//带权周转时间=周转时间/服务时间
    }

其中time为总运行时间。

五，对每个进程的最终结果进行输出

声明：

void print(struct job jobs[50], int n);

代码如下：

void print(struct job jobs[50], int n)
{
    int i;
    double avertime;
    double dqzz_avertime;
    int sum_runtime = 0;
    double  sum_time = 0.00;
    printf("作业名  到达时间 运行时间 完成时间 周转时间 带权周转时间\n");
    for (i = 0; i < n; i++)
    {
        printf("%s        %2d        %2d        %2d        %2d        %.2f\n", jobs[i].name, jobs[i].starttime, jobs[i].needtime, jobs[i].endtime, jobs[i].runtime, jobs[i].dqzz_time);
        sum_runtime = sum_runtime + jobs[i].runtime;
        sum_time = sum_time + jobs[i].dqzz_time;
    }
    avertime = sum_runtime * 1.0 / n;
    dqzz_avertime = sum_time * 1.000 / n;
    printf("平均周转时间:%.2f \n", avertime);
    printf("平均带权周转时间:%.3f \n", dqzz_avertime);
    printf("\n");
}

六，运行结果

1，先来先服务算法：

第1关:先来先服务调度算法,visual studio,c语言,算法

2，短作业优先算法：

第1关:先来先服务调度算法,visual studio,c语言,算法 

3，优先级调度算法：

第1关:先来先服务调度算法,visual studio,c语言,算法 

4，时间片轮转算法：

第1关:先来先服务调度算法,visual studio,c语言,算法

七，总结

每个算法都有自己的优缺点，我个人的话，则更倾向于优先级调度算法，既考虑到了长进程的等待时间，也考虑到了短作业稍稍优先的模式。

全部运行代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
struct job {
    char name[10];      //作业的名字
    int starttime;      //作业到达系统时间
    int needtime;       //作业服务时间
    int runtime;        //作业周转时间
    int endtime;        //作业结束时间
    double dqzz_time;    //带权周转时间
};
void FCFS(struct job jobs[50], int n);//先来先服务算法
void SJF(struct job jobs[50], int n);//短作业优先算法
void HRRN(struct job jobs[50],int n);//优先调度算法
void RR(struct job jobs[50],int n);//时间片轮转算法
void print(struct job jobs[50], int n);
int main() {
    struct job jobs[50];
    int n, i; //n个作业
    int flag;
    printf("请选择调度算法，1：先来先服务 2:短作业优先 3:优先调度算法 4:时间轮转调度算法");
    scanf("%d", &flag);
    printf("请输入作业个数:");
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        printf("请输入第%d个作业的作业名:\n",i + 1);
        scanf("%s", jobs[i].name); //作业名
        printf("请输入第%d个作业的到达时间:\n",i + 1);
        scanf("%d", &jobs[i].starttime);//到达时间
        printf("请输入第%d个作业的服务时间:\n",i + 1);
        scanf("%d", &jobs[i].needtime);//运行（服务时间）时间
    }
    printf("\n");
    switch (flag){
    case 1:
        FCFS(jobs, n);
        printf("先来先服务（FCFS）算法运行结果：\n");
        print(jobs, n);
        break;
    case 2:
        SJF(jobs, n);
        printf("短作业优先（SJF）算法运行结果：\n");
        print(jobs, n);
        break;
    case 3:
        HRRN(jobs, n);
        printf("优先调度算法（HRRN）算法运行结果：\n");
        print(jobs, n);
        break;
    case 4:
        RR(jobs, n);
        printf("时间轮转调度算法（RR）算法运行结果：\n");
        print(jobs, n);
        break;
    }
}
void FCFS(struct job jobs[50], int n){
    int i = 0, j = 0;
    char t_name[10];//用于交换的临时变量
    int t_time;//用于交换的临时变量
    for (i = 0; i < n; i++) //按作业到达系统时间进行排序，最早到达的排在最前面 
    {
        for (j = i; j < n; j++) //按作业到达系统时间进行排序，最早到达的排在最前面 
        {
            if (jobs[j].starttime < jobs[i].starttime)
            {   //把到达时间早的赋值到t_time
                t_time = jobs[j].starttime;
                jobs[j].starttime = jobs[i].starttime;
                jobs[i].starttime = t_time;
                //把到达时间早的赋值到t_time
                t_time = jobs[j].needtime;
                jobs[j].needtime = jobs[i].needtime;
                jobs[i].needtime = t_time;
                strcpy(t_name, jobs[j].name);//这里用strcpy函数是由于name变量为字符串类型，不能用=赋值
                strcpy(jobs[j].name, jobs[i].name);
                strcpy(jobs[i].name, t_name);//利用t_name数组进行交换排序
            }
        }
    }
    for (i = 0; i < n; i++)
    {
        if (i == 0)
        {   //第一个进程
            jobs[i].runtime = jobs[i].needtime;     //周转时间=服务时间
            jobs[i].endtime = jobs[i].starttime + jobs[i].needtime;    //结束时间=到达时间+服务时间    
        }
        else if (jobs[i].starttime > jobs[i - 1].endtime)
        {   //第i个进程到达系统时，第i-1个进程已运行完毕
            jobs[i].runtime = jobs[i].needtime;
            jobs[i].endtime = jobs[i].starttime + jobs[i].needtime;
        }
        else
        {   //第i个进程到达系统时，第i-1个进程未运行完毕
            jobs[i].runtime = jobs[i].needtime + jobs[i - 1].endtime - jobs[i].starttime;
            //周转时间 = 服务时间 + 前一个的结束时间 - 到达时间(结束时间 = 服务时间 + 前一个的结束时间)
            jobs[i].endtime = jobs[i].starttime + jobs[i].runtime;  //结束时间 = 到达时间 + 周转时间
        }
        jobs[i].dqzz_time = jobs[i].runtime * 1.0 / jobs[i].needtime;//带权周转时间=周转时间/服务时间
    }
}
void SJF(struct job jobs[50], int n)
{
    int i = 0, j = 0;
    char t_name[10];//用于交换的临时变量
    int t_time;//用于交换的临时变量
    for (i = 0; i < n; i++) //按作业到达系统时间进行排序，最早到达的排在最前面 
    {
        for (j = i; j < n; j++) //按作业到达系统时间进行排序，最早到达的排在最前面 
        {
            if (jobs[j].starttime < jobs[i].starttime)
            {   //把到达时间早的赋值到t_time
                t_time = jobs[j].starttime;
                jobs[j].starttime = jobs[i].starttime;
                jobs[i].starttime = t_time;
                //把到达时间早的赋值到t_time
                t_time = jobs[j].needtime;
                jobs[j].needtime = jobs[i].needtime;
                jobs[i].needtime = t_time;
                strcpy(t_name, jobs[j].name);//这里用strcpy函数是由于name变量为字符串类型，不能用=赋值
                strcpy(jobs[j].name, jobs[i].name);
                strcpy(jobs[i].name, t_name);//利用t_name数组进行交换排序
            }
        }
    }
    jobs[0].endtime = jobs[0].starttime + jobs[0].needtime;//结束时间=到达时间+服务时间
    jobs[0].runtime = jobs[0].needtime;//周转时间=服务时间
    jobs[0].dqzz_time = jobs[0].runtime * 1.0 / jobs[0].needtime;//带权周转时间=周转时间/服务时间
    for (i = 1; i < n; i++)
    {
        for (j = i; j < n; j++)
        {
            //按最短运行时间排序
            //关于jobs[i - 1].endtime > jobs[j].starttime如果到达时间太迟于上一轮的结束时间，会造成浪费时间资源用以等待
            if (jobs[i - 1].endtime > jobs[j].starttime && jobs[j].needtime < jobs[i].needtime)
            {
                t_time = jobs[i].starttime;
                jobs[i].starttime = jobs[j].starttime;
                jobs[j].starttime = t_time;
                //把短的赋值到临时变量t_time中
                t_time = jobs[i].needtime;
                jobs[i].needtime = jobs[j].needtime;
                jobs[j].needtime = t_time;
                strcpy(t_name, jobs[i].name);   //将第二个参数的值复制给第一个参数，返回第一个参数
                strcpy(jobs[i].name, jobs[j].name);
                strcpy(jobs[j].name, t_name);
            }                 //按最短运行时间排序
        }
        if (jobs[i].starttime > jobs[i - 1].endtime)
        {       //第i个进程到达系统时，第i-1个进程已运行完毕
            jobs[i].endtime = jobs[i].starttime + jobs[i].needtime;//结束时间=到达时间+服务时间
            jobs[i].runtime = jobs[i].needtime;//周转时间=服务时间
        }
        else
        {
            jobs[i].endtime = jobs[i - 1].endtime + jobs[i].needtime;//结束时间=上一个的结束时间+服务时间
            jobs[i].runtime = jobs[i].endtime - jobs[i].starttime;//周转时间=结束时间-到达时间
        }
        jobs[i].dqzz_time = jobs[i].runtime * 1.0 / jobs[i].needtime;
    }
}
void HRRN(struct job jobs[50], int n) {
    int i = 0, j = 0;
    double hrrn[10];//动态优先级
    char t_name[10];//用于交换的临时变量
    int t_time;//用于交换的临时变量
    for (i = 0; i < n; i++) {
        if (jobs[i].starttime == 0) {
            t_time = jobs[0].starttime;
            jobs[0].starttime = jobs[i].starttime;
            jobs[i].starttime = t_time;
            //把第一个到达的放入临时变量t_time中
            t_time = jobs[0].needtime;
            jobs[0].needtime = jobs[i].needtime;
            jobs[i].needtime = t_time;
            strcpy(t_name, jobs[0].name);   
            strcpy(jobs[0].name, jobs[i].name);
            strcpy(jobs[i].name, t_name);
        }
    }
    hrrn[0] = 1;//第一个运行的进程不需要等待，优先级=1
    jobs[0].endtime = jobs[0].needtime;//第一个进程的结束时间即其服务时间
    for (i = 1; i < n; i++) 
    {
        for (j = i; j < n; j++) 
        {
            //优先级=（等待时间+要求服务时间）/ 要求服务时间
            hrrn[j] = static_cast<double>(jobs[i - 1].endtime - jobs[j].starttime + jobs[j].needtime) / jobs[j].needtime;
        }//这是此时第i个进程结束后的所有进程的优先级
        for (int t = i + 1; t < n; t++) {
            if (hrrn[t] > hrrn[i]) {
                t_time = jobs[t].starttime;
                jobs[t].starttime = jobs[i].starttime;
                jobs[i].starttime = t_time;
                //把短的赋值到临时变量t_time中
                t_time = jobs[t].needtime;
                jobs[t].needtime = jobs[i].needtime;
                jobs[i].needtime = t_time;
                strcpy(t_name, jobs[t].name);
                strcpy(jobs[t].name, jobs[i].name);
                strcpy(jobs[i].name, t_name);
            }//按优先级进行比较并排序
        }
        jobs[i].endtime = jobs[i - 1].endtime + jobs[i].needtime;//第i个进程的结束时间=上一个的结束时间+服务时间
    }
    for (i = 0; i < n; i++)
    {
        if (i == 0)
        {   //第一个进程
            jobs[i].runtime = jobs[i].needtime;     //周转时间=服务时间
            jobs[i].endtime = jobs[i].starttime + jobs[i].needtime;    //结束时间=到达时间+服务时间    
        }
        else if (jobs[i].starttime > jobs[i - 1].endtime)
        {   //第i个进程到达系统时，第i-1个进程已运行完毕
            jobs[i].runtime = jobs[i].needtime;
            jobs[i].endtime = jobs[i].starttime + jobs[i].needtime;
        }
        else
        {   //第i个进程到达系统时，第i-1个进程未运行完毕
            jobs[i].runtime = jobs[i].needtime + jobs[i - 1].endtime - jobs[i].starttime;
            //周转时间 = 服务时间 + 前一个的结束时间 - 到达时间(结束时间 = 服务时间 + 前一个的结束时间)
            jobs[i].endtime = jobs[i].starttime + jobs[i].runtime;  //结束时间 = 到达时间 + 周转时间
        }
        jobs[i].dqzz_time = jobs[i].runtime * 1.0 / jobs[i].needtime;//带权周转时间=周转时间/服务时间
    }
}
void RR(struct job jobs[50], int n) {
    int t, s = 0, time = 0;
    int f[1000];
    printf("请输入时间片的大小：");
    scanf("%d",&t);
    int i = 0, j = 0;
    for (i = 0; i < 1000; i++) {
        f[i] = 0;
    }
    char t_name[10];//用于交换的临时变量
    int t_time;//用于交换的临时变量
    for (i = 0; i < n; i++) //按作业到达系统时间进行排序，最早到达的排在最前面 
    {
        for (j = i; j < n; j++) //按作业到达系统时间进行排序，最早到达的排在最前面 
        {
            if (jobs[j].starttime < jobs[i].starttime)
            {   //把到达时间早的赋值到t_time
                t_time = jobs[j].starttime;
                jobs[j].starttime = jobs[i].starttime;
                jobs[i].starttime = t_time;
                //把到达时间早的赋值到t_time
                t_time = jobs[j].needtime;
                jobs[j].needtime = jobs[i].needtime;
                jobs[i].needtime = t_time;
                strcpy(t_name, jobs[j].name);//这里用strcpy函数是由于name变量为字符串类型，不能用=赋值
                strcpy(jobs[j].name, jobs[i].name);
                strcpy(jobs[i].name, t_name);//利用t_name数组进行交换排序
            }
        }
    }
    for (i = 0; i < n; i++) {
        s += jobs[i].needtime;//s是用来确认所有进程全部结束
        f[i] = jobs[i].needtime;//f[i]用以存储单个进程剩余所需运行时间
    }
    do {
        for (i = 0; i < n; i++) {
            if (f[i]) {         //若f[i] == 0，则说明本进程的运行已全部结束
                //如果本进程剩余时间比时间片大，则总运行时间加一个时间片，本进程剩余运行时间减一个时间片，并将s减一个时间片
                if (f[i] > t) { 
                    time += t;
                    f[i] -= t;
                    s -= t;
                }
                //如果本进程剩余时间比时间片小，则总运行时间加一个时间片，s减一个本进程剩余运行时间，并将本进程剩余运行时间归零
                else {
                    time += t;
                    jobs[i].endtime = time;
                    s -= f[i];
                    f[i] = 0;
                }
            }
        }
    } while (s);
    for (i = 0; i < n; i++) {
        jobs[i].runtime = jobs[i].endtime - jobs[i].starttime;//周转时间 = 结束时间 - 到达时间
        jobs[i].dqzz_time = jobs[i].runtime * 1.0 / jobs[i].needtime;//带权周转时间=周转时间/服务时间
    }
}
void print(struct job jobs[50], int n)
{
    int i;
    double avertime;
    double dqzz_avertime;
    int sum_runtime = 0;
    double  sum_time = 0.00;
    printf("作业名  到达时间 运行时间 完成时间 周转时间 带权周转时间\n");
    for (i = 0; i < n; i++)
    {
        printf("%s        %2d        %2d        %2d        %2d        %.2f\n", jobs[i].name, jobs[i].starttime, jobs[i].needtime, jobs[i].endtime, jobs[i].runtime, jobs[i].dqzz_time);
        sum_runtime = sum_runtime + jobs[i].runtime;
        sum_time = sum_time + jobs[i].dqzz_time;
    }
    avertime = sum_runtime * 1.0 / n;
    dqzz_avertime = sum_time * 1.000 / n;
    printf("平均周转时间:%.2f \n", avertime);
    printf("平均带权周转时间:%.3f \n", dqzz_avertime);
    printf("\n");
}

（本文仅供学习时参考，如有错误，纯属作者技术不到位，不足之处请多指教，谢谢）文章来源地址https://www.toymoban.com/news/detail-773731.html

到了这里，关于操作系统有关进程调度算法（含先来先服务，短作业优先，优先级调度算法和时间片轮转调度算法）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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

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

相关文章

  • 「 操作系统 」聊聊进程调度算法

    「 操作系统 」聊聊进程调度算法

    图文并茂！谈谈进程调度那些算法 Cone 进程调度/页面置换/磁盘调度算法 xiaolinCoding 图解经典的进程调度算法 飞天小牛肉 进程调度算法是操作系统中非常重要的一部分，它决定了操作系统中各个进程的执行顺序和时间片。在单核CPU下，任何时刻都只可能有一个程序在执行，比

    2024年02月04日
    浏览(59)
  • 【操作系统之进程调度算法习题】

    【操作系统之进程调度算法习题】

    在一个具有三道作业的批处理系统中，作业调度采用先来先服务(FCFS) 调度算法,进程调度采用 短作业优先调度算法。现有如下所示的作业序列, 注意 1.具有三道作业的批处理系统指的是内存最多能有3个作业; 2.表格样式是考试时候的格式，练习时候也按这个格式练习各作业的周

    2024年02月11日
    浏览(46)
  • 操作系统实验—进程调度算法（java）

    操作系统实验—进程调度算法（java）

    目录 文章目录 前言 一、实验原理 二、实验步骤 1.创建PCB类 2.创建创建类 3.设计主窗口类 4.调度界面函数 5.算法类及其调度算法通用函数 6.进程调度算法函数 总结 操作系统实验1：进程调度算法，步骤3、4在一个类中，步骤5、6在一个类中。 (1)先到先服务调度算法:按照进程提

    2024年02月04日
    浏览(49)
  • 【操作系统】期末速成之计算题：进程调度算法

    【操作系统】期末速成之计算题：进程调度算法

    先来先服务是非抢占式的算法 一个🌰 例题：各进程到达就绪队列的时间、需要的运行时间如下表所示。使用先来先服务调度算法，计算各进程的等待时间、平均等待时间、周转时间、平均周转时间、带权周转时间、平均带权周转时间。 进程 到达时间 运行时间 P1 0 7 P2 2 4

    2024年02月11日
    浏览(41)
  • 用代码模拟操作系统进程调度算法（Python）

    用代码模拟操作系统进程调度算法（Python）

     引言 近日，在学习完操作系统的进程调度部分后，我萌生了一个有趣的想法：通过编写代码来模拟进程调度算法，以加深自己对这一知识点的理解。于是，我花了一整天的时间投入到了这个突发奇想的实践中。  背景 进程调度是操作系统中的重要概念，它决定了如何合理地

    2024年02月06日
    浏览(55)

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

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

    2024年02月05日
    浏览(73)
  • 操作系统进程调度算法（c语言模拟实现）

    操作系统进程调度算法（c语言模拟实现）

            前言： 本文旨在分享如何使用c语言对操作系统中的部分进程调度算法进行模拟实现，以及算法描述的讲解， 完整代码放在文章末尾，欢迎大家自行拷贝调用 目录 常见的调度算法 数据结构 先来先服务调度算法 算法模拟思路： 算法模拟：  最短作业优先调度算法

    2024年02月06日
    浏览(55)
  • 操作系统进程调度算法的模拟实现（c语言版本）

    操作系统进程调度算法的模拟实现（c语言版本）

            前言： 本文旨在分享如何使用c语言对操作系统中的部分进程调度算法进行模拟实现，以及算法描述的讲解， 完整代码放在文章末尾，欢迎大家自行拷贝调用 目录 常见的调度算法 数据结构 先来先服务调度算法 算法模拟思路： 算法模拟：  最短作业优先调度算法

    2024年02月06日
    浏览(55)
  • 【操作系统】c语言--进程调度算法(FCFS和SPN)

    【操作系统】c语言--进程调度算法(FCFS和SPN)

    创作不易，本篇文章如果帮助到了你，还请点赞 关注支持一下♡𖥦)!! 主页专栏有更多知识，如有疑问欢迎大家指正讨论，共同进步！ 🔥c++系列专栏：C/C++零基础到精通 🔥 给大家跳段街舞感谢支持！ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ c语言内容💖：

    2024年02月12日
    浏览(47)
  • 操作系统进程线程（一）—进程线程协程区别、多进程多线程、进程调度算法、进程线程通信

    操作系统进程线程（一）—进程线程协程区别、多进程多线程、进程调度算法、进程线程通信

    定义上 进程： 资源分配和拥有 的基本单位，是调度的基本单位。 运行一个可执行程序会创建一个或者多个进程；进程就是运行起来的程序 线程：程序 执行 基本单位，轻量级进程。 每个进程中都有唯一的主线程 ，主线程和进程是相互依赖的关系。 协程： 用户态 的轻量级

    2024年02月01日
    浏览(57)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包