您的位置：360文档中心› 作业调度实例(全部代码)

作业调度实例(全部代码)

合集下载

sjf算法例题详解

sjf算法例题详解

sjf算法例题详解SJF算法例题解析什么是SJF算法•SJF（Shortest Job First）算法是一种非抢占式的调度算法，也被称为最短作业优先算法。

•SJF调度算法根据进程的执行时间来进行调度，先执行执行时间短的任务，以减少平均等待时间。

SJF算法的执行过程1.将进程按照执行时间从小到大进行排序，得到一个等待队列。

2.从等待队列中选择执行时间最短的进程进行执行。

3.若有多个进程的执行时间相同，则根据其到达时间进行选择，选择最先到达的进程执行。

4.执行完当前进程后，更新等待队列，继续选择执行时间最短的进程进行执行，直到所有进程执行完毕。

SJF算法的例题解析•假设有以下五个进程需要执行，进程的执行时间和到达时间如下：进程 | 到达时间 | 执行时间 |—- | | |P1 | 0 | 5 |P2 | 1 | 3 |P3 | 2 | 8 |P4 | 3 | 6 |P5 | 4 | 4 |1.首先，将进程按照到达时间进行排序：进程 | 到达时间 | 执行时间 |—- | | |P1 | 0 | 5 |P2 | 1 | 3 |P3 | 2 | 8 |P4 | 3 | 6 |P5 | 4 | 4 |2.然后，根据执行时间进行排序，若执行时间相同，则根据到达时间进行选择：进程 | 到达时间 | 执行时间 |—- | | |P2 | 1 | 3 |P5 | 4 | 4 |P1 | 0 | 5 |P4 | 3 | 6 |P3 | 2 | 8 |3.根据执行时间选择要执行的进程：进程 | 到达时间 | 执行时间 |—- | | |P2 | 1 | 3 |4.执行完P2进程后，更新等待队列：进程 | 到达时间 | 执行时间 |—- | | |P5 | 4 | 4 |P1 | 0 | 5 |P4 | 3 | 6 |P3 | 2 | 8 |5.继续选择执行时间最短的进程执行，执行完毕后更新等待队列，直到所有进程执行完毕。

作业调度之最短作业优先算法5例题解析

作业调度之最短作业优先算法5例题解析

作业调度之最短作业优先算法5例题解析例题一、某系统采用不能移动已在主存储器中作业的可变分区方式管理主存储器，现有供用户使用的主存空间100K,系统配有4台磁带机，有一批作业见下表：作业序号进输入井时间要求计算时间需要主存容量申请磁带机数110:0025分钟15K2台210:2030分钟60K1台310:3010分钟50K3台410:3520分钟10K2台510:4015分钟30K2台按计算时间最短者优先算法如下表：我的解释：系统首先装入1、2、4,但1结束时4沿未到达，因此先执行2;2执行完毕后，资源可以分配给3或5,考虑5的时间短优先分配5并执行，执行完5后，主存中只有4已就绪并等待执行，因此开始执行4,执行4的同时系统会将作业3装入主存，最后自然执行作业3;因此最后的顺序是：1\2\5\4\3作业序号进输入井时间进入主存时间开始计算时间结束计算时间周转时间解释110:0010:1010:00102525此时输入井中只有一个作业且满足资源要求，因此被选中运行。

2102010：2010：2510：5535作业2到达输入井，满足资源要求，装入主存，等到作业1运行完毕进入运行。

510:4010:5510:5511：1030由于作业3要求主存空间无法满足，因此作业4先行一步装入主存，当作业2让出处理器的同时，作业5满足资源要求进入主存就绪。

根据算法作业5先进入处理器运行最后作业3装入主存并运行平均周转时间：（25+35+30+55+70/5=43分钟 ［分析］解答本题时应注意如下几个问题：第一，系统采用的是多道程序设计技术，但没有限定并行工作的道数，因此， 只要当前尚未分配的资源可以满足在输入井中等待的某些作业的要求时，作业 调度可以按照给定的算法从中选择一个或多个作业装人主存储器；第二，采用可变分区方式管理主存储器，但没给出主存空间的分配算法，因而,只要有合适的空间就可分配，题中还规定可用移动技术来合并分散的空闲区； 第三，对磁带机采用静态分配；第四，进程调度采用可抢占的最高优先级调度算法，即对已被装人主存储器的作业而言优先级高的作业可抢占处理器执行；第五，虽然作业需要使用磁带机，但题意中已提示忽略磁带机和调度所花的时问，所以，解题时不必考虑外围设备的启动二八D 中断等复杂情况，只需把它们当作纯计算型的作业； 第六，由于没有规定什么时候开始进行作业调度，故在一般情况下只要输入井中有等待处理的作业就可按选定的算法去选择满足必要条件的作业。

短作业优先调度算法例题详解

短作业优先调度算法例题详解

短作业优先调度算法例题详解
（原创实用版）
目录
1.短作业优先调度算法的概述
2.算法的例子
3.算法的详解
4.算法的优点和缺点
正文
一、短作业优先调度算法的概述
短作业优先调度算法（Shortest Job First, SJF）是一种常见的作业调度算法。

这种算法的基本原则是优先执行估计运行时间最短的作业，直到完成。

然后，再从剩下的作业中选择估计运行时间最短的作业执行，以此类推。

这种算法的目的是尽可能减少作业的平均等待时间。

二、算法的例子
假设有一个计算机系统，其中有三个作业需要执行，它们的运行时间分别是：作业 1 需要 20 分钟，作业 2 需要 30 分钟，作业 3 需要 10 分钟。

按照短作业优先调度算法，执行顺序应为：先执行作业 3（10 分钟），然后执行作业 1（20 分钟），最后执行作业 2（30 分钟）。

三、算法的详解
短作业优先调度算法的执行过程可以分为以下几个步骤：
1.首先，将等待执行的作业按照运行时间从短到长进行排序。

2.然后，选择运行时间最短的作业执行，直到完成。

3.完成后，再从剩下的作业中选择运行时间最短的作业执行，以此类推。

四、算法的优点和缺点
短作业优先调度算法的优点是能够使得作业的平均等待时间最短，从而提高了系统的效率。

然而，这种算法也有其缺点，那就是长作业可能会被频繁地打断，导致其执行效率低下。

进程调度算法代码

进程调度算法代码

进程调度算法代码进程调度算法是操作系统中的一种重要机制，它决定了在多道程序环境下，如何安排各个进程的执行顺序和时间片。

不同的进程调度算法有不同的实现方式和优缺点，本文将就常见的几种进程调度算法进行详细介绍。

1. 先来先服务（FCFS）先来先服务是最简单、最直观的进程调度算法。

它按照进程到达时间的先后顺序进行调度，即先到达的进程先执行。

当一个进程开始执行后，直到该进程执行完毕或者发生某些阻塞事件才会切换到另一个进程。

FCFS算法代码如下：```void FCFS(){int i;for(i=0;i<n;i++){run(p[i].need_time);if(i!=n-1){wait(p[i+1].arrive_time-p[i].arrive_time-p[i].need_time); }}}```其中，p数组表示所有需要执行的进程，n表示总共有多少个需要执行的进程。

run函数表示运行该进程所需时间片，wait函数表示等待下一个进程到达所需时间。

FCFS算法优点是简单易懂、公平性好，但其缺点也很明显：无法处理短作业优先问题、平均等待时间长等。

2. 短作业优先（SJF）短作业优先是一种非抢占式的进程调度算法，它根据每个进程的执行时间来进行排序，执行时间短的进程先执行。

如果有多个进程的执行时间相同，则按照到达时间的先后顺序进行调度。

SJF算法代码如下：```void SJF(){int i,j;for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(p[i].need_time>p[j].need_time){swap(p[i],p[j]);}}}for(i=0;i<n;i++){run(p[i].need_time);if(i!=n-1){wait(p[i+1].arrive_time-p[i].arrive_time-p[i].need_time); }}}```其中，swap函数表示交换两个进程的位置。

操作系统五种进程调度算法的代码

操作系统五种进程调度算法的代码

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。

作业调度算法源代码

作业调度算法源代码

作业调度算法源代码#include <stdio.h>#include <stdlib.h>#define ReadyLimit 5typedef struct job{int id;int needtime;int arrivetime;int starttime;int finishtime;int remainder;float priority;struct job *next;} jobnode,*jobnodeptr;jobnodeptr joblist,readylist,runlist,collectlist; int systime;void init(void){joblist=(jobnodeptr)malloc(sizeof(jobnode)); joblist->id=-1;joblist->next=NULL;readylist=(jobnodeptr)malloc(sizeof(jobnode)); readylist->id=-1;readylist->next=NULL;collectlist=(jobnodeptr)malloc(sizeof(jobnode));collectlist->id=-1;collectlist->next=NULL;runlist=NULL;systime=-1;}void file2joblist(void){FILE *fp;jobnodeptr p,q;int i,j;fp=fopen("input.txt","rt");if (!fp){printf("Can't open file");exit(1);}p=joblist;fscanf(fp,"%d",&i);for (j=0;j<i;j++){q=(jobnodeptr)malloc(sizeof(jobnode));fscanf(fp,"%d%d%d",&q->id,&q->needtime,&q->arrivetime); q->starttime=0;q->finishtime=0;q->remainder=q->needtime;q->priority=-1.0;p->next=q;p=q;}p->next=NULL;fclose(fp);}void jobdispatch(void)/*作业调度*/{jobnodeptr p,q;int count=0;float maxpri;p=readylist;/*计算readylist中进程的个数*/while (p->next){count++;p=p->next;}if (count>=ReadyLimit) return;p=joblist->next;/*计算已到达作业的响应比*/while (p){if (p->arrivetime<=systime)p->priority=(systime-p->arrivetime)/(float)p->needtime; p=p->next;}while (count<ReadyLimit){maxpri=-1.0;p=joblist;q=NULL;while (p->next){if (p->next->priority > maxpri){maxpri = p->next->priority; q = p;}p=p->next;}if (q){p=q->next;q->next=p->next;p->next=NULL;q=readylist;while (q->next)q=q->next;q->next=p;p->starttime=systime;count++;}else break;}}void processdispatch(void)/*进程调度*/{runlist=readylist->next;if (runlist) {readylist->next=runlist->next;runlist->next=NULL;}}void running(void)/*模拟运行*/{jobnodeptr p;if (runlist){printf("%4d:%-4d ",systime,runlist->id);runlist->remainder--;if (runlist->remainder){p=readylist;while (p->next)p=p->next;p->next=runlist;}else{runlist->finishtime=systime;p=collectlist;while (p->next&& (p->next->starttime < runlist->starttime) /*&& (p->next->id < runlist->id)*/)p=p->next;runlist->next=p->next;p->next=runlist;}runlist=NULL;}else printf("%4d:idle ",systime);}void display(void)/*显示信息*/{jobnodeptr p;printf("id----- need--- arrive- start-- finish-\n");p=collectlist->next;while (p){printf("%-7d %-7d %-7d %-7d %-7d\n",p->id,\p->needtime,p->arrivetime,p->starttime,p->finishtime); p=p->next;}}void freeall(void){jobnodeptr p,q;p=collectlist;while (p){q=p;p=p->next;free(q);}free(joblist);free(readylist);}int main(void){init();file2joblist();while (1){systime++;jobdispatch();processdispatch();running();if (joblist->next==NULL && readylist->next==NULL)break;}printf("\n\n"); display();freeall();getchar();return 0;}。

流水线作业问题解决的代码

流水线作业问题解决的代码

流水线作业调度问题Time Limit: 1000 ms Case Time Limit: 1000 ms Memory Limit: 64 MBDescriptionN个作业{1,2,………,n}要在由两台机器M1和M2组成的流水线上完成加工。

每个作业加工的顺序都是先在M1上加工，然后在M2上加工。

M1和M2加工作业i所需的时间分别为ai和bi，1≤i≤n。

流水作业高度问题要求确定这n个作业的最优加工顺序，使得从第一个作业在机器M1上开始加工，到最后一个作业在机器M2上加工完成所需的时间最少。

Input输入包括若干测试用例，每个用例输入格式为：第1行一个整数代表任务数n，当为0时表示结束,或者输入到文件结束(EOF)第2行至第n+1行每行2个整数，代表任务在M1,M2上所需要的时间Output输出一个整数，代表执行n个任务的最短时间Sample InputOriginal Transformed11 2Sample OutputOriginal Transformed3思路：这一题的难度还是相当不小的。

首先是一个两道工序的流水线排序问题（“同顺序”排序问题）。

用Johnson算法来解决两道工序的流水线排序相对比较简单易懂，而且可以得到最优解。

Johnson算法的大致内容如下：(1)从加工时间矩阵中找出最短的加工时间。

(2)若最短的加工时间出现在M1上，则对应的工件尽可能往前排；若最短加工时间出现在M2上，则对应工件尽可能往后排。

然后，从加工时间矩阵中划去已排序工件的加工时间。

若最短加工时间有多个，则任挑一个。

(3)若所有工件都已排序，停止。

否则，转步骤(1)。

加工时间矩阵即为所有工件分别在两道工序上加工所需时间。

M1为工序1,M2为工序2（进入工序2之前，工序1必须完工）。

Johnson算法之所以能求出最优解，是因为：1.所有工件没开始加工时，只能加工工序1，工序2不得不空着。

2.我们只能利用工序2的加工过程尽量省去工序1的时间。

C++程序-流水作业调度

C++程序-流水作业调度

一、问题描述给定n个作业，每个作业有两道工序，分别在两台机器上处理。

一台机器一次只能处理一道工序，并且一道工序一旦开始就必须进行下去直到完成。

一个作业只有在机器1上的处理完成以后才能由机器2处理。

假设已知作业i在机器j上需要的处理时间为t[i,j]。

流水作业调度问题就是要求确定一个作业的处理顺序使得尽快完成这n个作业。

二、算法分析n个作业{1,2,…,n}要在由2台机器M和2M组成的流水线上完成加工。

每1个作业加工的顺序都是先在M上加工，然后在2M上加工。

1M和2M加工作业i所1需要的时间分别为t[i,1]和t[i,2], n1.流水作业调度问题要求确定这ni≤≤个作业的最优加工顺序，使得从第一个作业在机器M上开始加工，到最后一个1作业在机器M上加工完成所需的时间最少。

2从直观上我们可以看到，一个最优调度应使机器M没有空闲时间，且机器2M1的空闲时间是最少。

在一般情况下，机器M上会有机器空闲和作业积压两种情2况。

设全部作业的集合为}N=。

N2,1{n,....,S⊆是N的作业子集。

在一般情况下，机器M开始加工S中作业时，机器2M还在加工其他作业，要等时间t后才能利1用。

将这种情况下完成S中作业所需的最短时间计为),ST。

流水作业调度问题(t的最优解为)0,T。

(N1.证明流水作业调度问题具有最优子结构设a是所给n个流水作业的一个最优调度，它所需要的加工时间为']1),1([T a t +。

其中，'T 是在机器2M 的等待时间为]2),1([a t 时，安排作业)(),......,3(),2(n a a a 所需的时间。

记)}1({a N S -=，则我们可以得到])2),1([,('a t S T T =。

事实上，有T 的定义可知])2),1([,('a t S T T ≥.若])2),1([,('a t S T T >，设'a 是作业集S 在机器2M 的等待时间为]2),1([a t 情况下的一个最优调度。

操作系统五种进程调度算法的代码

操作系统五种进程调度算法的代码

进程调度算法的模拟实现⏹实验目的1．本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

2．利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、轮转调度算法RR、最短作业优先算法SJF、优先级调度算法PRIOR、最短剩余时间优先算法SRTF。

3．进行算法评价，计算平均等待时间和平均周转时间。

⏹实验内容及结果1．先来先服务算法2．轮转调度算法3. 优先级调度算法4. 最短时间优先算法5. 最短剩余时间优先算法⏹实验总结在此次模拟过程中，将SRTF单独拿了出来用指针表示，而其余均用数组表示。

⏹完整代码【Srtf.cpp代码如下：】//最短剩余时间优先算法的实现#include<stdio.h>#include<stdlib.h>#include<time.h>typedefstruct{int remain_time;//进程剩余执行时间int arrive_time;//进程到达时间int Tp;//进入就绪队列的时间int Tc;//进入执行队列的时间int To;//进程执行结束的时间int number;//进程编号}Process_Block;//定义进程模块typedefstruct _Queue{Process_Block PB;struct _Queue *next;}_Block,*Process;//定义一个进程模块队列中结点typedefstruct{Process head;//队列头指针Process end;//队列尾指针}Process_Queue;//进程队列Process_Queue PQ;//定义一个全局队列变量int t;//全局时间Process Run_Now;//当前正在运行的进程，作为全局变量void InitQueue(Process_Queue PQ){PQ.head ->next = NULL;PQ.end ->next = PQ.head;}/*初始化队列*/int IsEmpty(Process_Queue PQ){if(PQ.end->next == PQ.head)return 1;//队列空的条件为头指针指向尾指针并且尾指针指向头指针elsereturn 0;}/*判定队列是否为空队列*/void EnQueue(Process_Queue PQ,Process P){Process temp =(Process)malloc(sizeof(_Block));temp = PQ.end;temp->next->next = P;PQ.end->next = P;}/*插入队列操作*/Process DeQueue(Process_Queue PQ){if(IsEmpty(PQ))return NULL;Process temp = PQ.head->next;PQ.head->next= temp ->next;if(PQ.end->next == temp)PQ.end->next = PQ.head;return temp;}/*出列操作*/Process ShortestProcess(Process_Queue PQ){if(IsEmpty(PQ))//如果队列为空，返回{if(!Run_Now)return NULL;elsereturn Run_Now;}Process temp,shortest,prev;int min_time;if(Run_Now)//如果当前有进程正在执行，{shortest = Run_Now;//那么最短进程初始化为当前正在执行的进程，min_time = Run_Now->PB.remain_time;}else//如果当前没有进程执行，{shortest = PQ.head->next;//则最短进程初始化为队列中第一个进程min_time = PQ.head->next->PB.remain_time;}temp = PQ.head;prev = temp;while(temp->next){if(temp->next->PB.remain_time <min_time)//如果当前进程的剩余时间比min_time短，{shortest = temp->next;//则保存当前进程，min_time = shortest->PB.remain_time;prev=temp;//及其前驱}temp=temp->next;}if(shortest == PQ.end->next)//如果最短剩余时间进程是队列中最后一个进程，PQ.end->next = prev;//则需要修改尾指针指向其前驱prev->next = shortest->next;//修改指针将最短剩余时间进程插入到队头return shortest;}/*调度最短剩余时间的进程至队头*/void Run(){Run_Now->PB.remain_time--;//某一时间运行它的剩余时间减return;}/*运行函数*/void Wait(){return ;}int sum(intarray[],int n){int i,sum=0;for(i=0;i<n;i++)sum+=array[i];return sum;}int main(){PQ.head = (Process)malloc(sizeof(_Block));PQ.end = (Process)malloc(sizeof(_Block));Run_Now = (Process)malloc(sizeof(_Block));Run_Now =NULL;InitQueue(PQ);int i,N,Total_Time=0;//Total_Time为所有进程的执行时间之和printf("请输入计算机中的进程数目:\n");scanf("%d",&N);Process *P,temp;P = (Process*)malloc(N*sizeof(Process));int *wt,*circle_t;wt =(int*)malloc(N*sizeof(int));circle_t =(int*)malloc(N*sizeof(int));for(i=0;i<N;i++){P[i] = (Process)malloc(sizeof(_Block));P[i]->PB.number =i+1;P[i]->next =NULL;wt[i] =0;circle_t[i] =0;printf("输入第%d个进程的到达时间及剩余执行时间:\n",i+1);scanf("%d %d",&P[i]->PB.arrive_time,&P[i]->PB.remain_time);}for(i=0;i<N;i++)Total_Time+=P[i]->PB.remain_time;printf("\n进程按顺序运行依次为:\n");i=0;int k=0;for(t=0;;t++){if(Run_Now)//如果当前有进程正在执行{Run();if(t == P[i]->PB.arrive_time)//如果当前时间正好有进程进入{if(P[i]->PB.remain_time < Run_Now->PB.remain_time){temp = P[i];P[i] = Run_Now;Run_Now = temp;//则调度它至运行队列中，Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}EnQueue(PQ,P[i]);//并将当前运行进程重新插入队列中P[i]->PB.Tp=t;k++;i=(i+1)>(N-1)?(N-1):(i+1);}if(Run_Now->PB.remain_time == 0)//如果当前进程运行结束，{Run_Now->PB.To=t;//进程运行结束的时间circle_t[Run_Now->PB.number-1] +=t-Run_Now->PB.arrive_time;free(Run_Now);//则将它所占资源释放掉，Run_Now =NULL;//并修改Run_Now为NULLRun_Now = ShortestProcess(PQ);//从就绪队列中调出最短剩余时间进程至队头，if(!Run_Now)//如果队列为空，转为等待状态{if(IsEmpty(PQ) && k >= N) break;Wait();continue;}else{Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}}}else//如果当前运行进程为空，那么{if(t == P[i]->PB.arrive_time)//如果正好这时有进程入队{k++;EnQueue(PQ,P[i]);Run_Now = DeQueue(PQ);//则直接被调入运行队列中Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;printf("%d ",Run_Now->PB.number);i=(i+1)>(N-1)?(N-1):(i+1);}else{Wait();continue;}}}printf("\n");printf("平均等待时间是:\n%f\n",((float)sum(wt,N))/N);printf("平均周转时间是:\n%f\n",((float)sum(circle_t,N))/N);return 0;}//////////////////////////////////////////////////////【Process.cpp代码如下：】#include<iostream>#include<string>usingnamespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法void main(){int a;cout<<endl;cout<<" 选择调度算法："<<endl;cout<<" 1: FCFS 2: 时间片轮换3: 优先级调度4: 最短作业优先5: 最短剩余时间优先"<<endl; cin>>a;constint Size =30;Process process[Size] ;int num;int TimePice;cout<<" 输入进程个数:"<<endl;cin>>num;cout<<" 输入此进程时间片大小: "<<endl;cin>>TimePice;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<" 输入第"<< i+1<<" 个进程的名字、cpu时间和优先级:"<<endl;cin>>name;cin>> CpuTime>>Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" ( 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! )";cout<<endl; cout<<endl;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl; if(a==1)Fcfs(process,num,TimePice);elseif(a==2)TimeTurn( process, num, TimePice);elseif(a==3){Sort( process, num);Priority( process , num, TimePice);}else// 最短作业算法，先按时间从小到大排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;} // 直接插入排序后进程按优先级从小到大排列for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;} // 此排序后按优先级从大到小排列}/*最短作业优先算法的实现*/void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}/*先来先服务算法的实现*/void Fcfs( Process process[], int num, int Timepice){ // process[] 是输入的进程，num是进程的数目，Timepice是时间片大小while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}elseif(process[num-1].LeftTime==0){cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!"<<endl;num--;}else{cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<"";cout<<process[s].LeftTime <<" "<<process[s].leval<<" 等待"<<endl; ;}} // elsecout<<endl;system(" pause");cout<<endl;} // while}/*时间片轮转调度算法实现*/void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}elseif(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<"";cout<<process[s].LeftTime <<" "<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;} // elsecout<<endl;system(" pause");cout<<endl;} // while}/*优先级调度算法的实现*/void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! "<<endl;for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl; // 输出其他进程for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval ; if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}。

批处理系统的作业调度

批处理系统的作业调度

批处理系统的作业调度一、实验目的1.加深对作业概念的理解。

2.深入了解批处理系统如何组织作业、管理作业和调度作业。

二、实验预备知识1.作业的概念。

2.作业的创建。

3.作业的调度。

三、实验内容编写程序完成批处理系统中的作业调度，要求采用响应比高者优先的作业调度算法。

实验具体包括：首先确定作业控制块的内容，作业控制块的组成方式；然后完成作业调度；最后编写主函数对所做工作进行测试。

四、提示与讲解操作系统根据允许并行工作的道数和一定的算法从系统中选取若干作业把它们装入主存储器，使它们有机会获得处理器运行，这项工作被称为“作业调度”。

实现这部分功能的程序就是“作业调度程序”。

作业调度的实现主要有两个问题，一个是如何将系统中的作业组织起来；另一个是如何进行作业调度。

为了将系统中的作业组织起来，需要为每个进入系统的作业建立档案以记录和作业相关的信息，例如作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息存储器中的位置、指向下一个作业控制块的指针等信息。

这个记录作业相关信息的数据块称为作业控制块（JCB），并将系统中等待作业调度的作业控制块组织成一个队列，这个队列称为后备队列。

一个作业全部信息进入系统后，就为其建立作业控制块，并挂入后备队列。

当进行作业调度时，从后备队列中查找选择作业。

由于实验中没有实际作业，作业控制块中的信息内容只使用了实验中需要的数据。

作业控制块中首先应该包括作业名；其次是作业所需资源，根据需要，实验中只包括需要主存的大小（采用可移动的动态分区方式管理主存，作业大小就是需要主存的大小）、需要打印机的数量和需要磁带机的数量；采用响应比作业调度算法，为了计算响应比，还需要有作业的估计执行时间、作业在系统中的等待时间；另外，指向下一个作业控制块的指针必不可少。

实验中，作业控制块及队列的数据结构定义如下：typedef struct jcb {char name[4]; //作业名int length; //作业长度，所需主存大小int printer; //作业执行所需打印机的数量int tape; //作业所需磁带机的数量int runtime; //作业估计执行时间int waittime; 作业在系统中的等待时间int next; //指向下一个作业控制块的指针}JCB //作业控制块类型定义存放作业控制块的区域：define n 10 //假定系统中可容纳的作业数量为nJCB jobtable[10]; //作业表int jobcount ; //系统内现有作业数量将作业控制块组织成一个队列，实验中采用静态链表的方式模拟作业的后备队列，如下图所示。

短作业优先调度算法例题详解(一)

短作业优先调度算法例题详解(一)

短作业优先调度算法例题详解(一)短作业优先调度算法例题简介短作业优先调度算法（SJF）是一种常用的进程调度算法，也被称为最短作业优先调度算法。

它通过选择剩余执行时间最短的作业来调度进程，以提高系统的吞吐量和响应时间。

本文将在此背景下给出一个例题，并详细解释短作业优先调度算法的实现过程。

短作业优先调度算法的例题假设有以下四个进程需要执行：1.进程A，需要执行时间为5个单位时间2.进程B，需要执行时间为3个单位时间3.进程C，需要执行时间为8个单位时间4.进程D，需要执行时间为1个单位时间解题步骤使用短作业优先调度算法调度上述四个进程，按照以下步骤进行：1.计算每个进程的执行时间，得到以下结果：–进程A，需要执行时间为5个单位时间–进程B，需要执行时间为3个单位时间–进程C，需要执行时间为8个单位时间–进程D，需要执行时间为1个单位时间2.按照执行时间的大小对进程进行排序，得到以下顺序：–进程D（执行时间为1个单位时间）–进程B（执行时间为3个单位时间）–进程A（执行时间为5个单位时间）–进程C（执行时间为8个单位时间）3.按照排序后的顺序依次执行进程，得到以下调度结果：–进程D（执行时间为1个单位时间）–进程B（执行时间为3个单位时间）–进程A（执行时间为5个单位时间）–进程C（执行时间为8个单位时间）结论通过短作业优先调度算法，进程的执行顺序被合理调度，系统的响应时间得到了改善。

短作业优先调度算法可有效减少作业的平均等待时间，提高系统的吞吐量。

总之，短作业优先调度算法是一种简单且高效的进程调度算法，适用于在大多数情况下需要快速响应任务的系统。

它通过选择剩余执行时间最短的作业来调度进程，以提高系统性能。

在实际应用中，短作业优先调度算法需要根据系统实际情况进行调优，以获得更好的性能表现。

以上就是关于短作业优先调度算法例题的详细解释。

希望通过本文的介绍，读者能够对短作业优先调度算法有更加深入的了解。

假设有4个作业j1、j2、j3和j4,到达时间分别为0、1、1和3,运行时间分别为3、3、2和

假设有4个作业j1、j2、j3和j4,到达时间分别为0、1、1和3,运行时间分别为3、3、2和

假设有4个作业j1、j2、j3和j4,到达时间分别为0、1、1和3,运行时间分别为3、3、2和
本文主要介绍四个作业j1、j2、j3和j4的短程调度，根据其到达时
间和运行时间来分析贪婪算法，提出调度问题的解决方案。

一、四个作业j1、j2、j3和j4的短程调度
1. 四个作业的详细参数
以上四个作业的基本参数情况如下表所示：
| 作业 | 到达时间（t） | 运行时间（cpu） |
| :-----: | :-----------: | :------------: |
| j1 | 0 | 3 |
| j2 | 1 | 3 |
| j3 | 1 | 2 |
| j4 | 3 | 2 |
2. 贪婪算法的实施
在贪婪算法的实施，将作业按照到达时间以及运行时间一次进行排序，按照“到达时间先小后大，同到达时间即运行时间先小后大”的原则，
选择到达时间最短且花费cpu时间最短的作业，依次进行调度或运行，即j1，j3，j2，j4.
三、贪婪算法的总结
通过以上分析，可以得出用贪婪算法解决作业调度问题的总结：
1. 对于多个作业问题，可以根据作业的到达时间和运行时间，按照时间的先后顺序进行排序，依次选出最少用时的作业进行调度；
2. 对于每个作业问题，可以采用贪婪算法进行，以期达到最小的花费总时数，即时间的最优利用。

综上所述，用贪婪算法解决作业调度问题非常有效，可以让我们找到最优解，而且算法本身比较容易实现，使用起来效果比较好，可以满足不断变化的条件下多作业的解决方案，特别是多作业间有关联的短程作业调度问题的求解。

作业调度方案c语言

作业调度方案c语言

作业调度方案c语言作业调度方案可以在C语言中实现,以下是一个简单的示例代码:```c#include <stdio.h>#include <stdlib.h>#include <time.h>// 定义作业类class Job {public:Job(int job_num) {job_num = job_num;job_num_++;}void run() {while (true) {// 执行作业任务switch (job_num) {case 0:printf("0%d: 执行工作0", job_num);break;case 1:printf("1%d: 执行工作1", job_num);break;default:printf("未找到工作");break;}// 等待一定时间后继续执行printf("等待中...");const int delay = 50;srand(time(NULL));for (int i = 0; i < delay; i++) { printf("");}}}int job_num;};// 主函数int main() {// 创建几个作业对象Job jobs[3];for (int i = 0; i < 3; i++) {jobs[i].job_num = i;}// 指定运行顺序int start_num = 0;int end_num = 2;for (int i = 0; i < 3; i++) {if (start_num == jobs[i].job_num) { start_num++;break;}if (end_num == jobs[i].job_num) { end_num++;break;}}// 等待作业完成srand(time(NULL));printf("开始运行...");for (int i = 0; i < 3; i++) {jobs[i].run();}// 输出运行结果printf("运行结果:");for (int i = 0; i < 3; i++) {printf("%d ", jobs[i].job_num);}printf("");return 0;}```这个示例中,定义了一个`Job`类来表示作业任务,其中包含一个`run`方法,用于在后台运行作业任务。

作业调度实验报告

作业调度实验报告

作业调度实验报告1. 实验目的通过本次实验，使学生了解作业调度算法的基本原理和实现方法，掌握作业调度的实际应用，提高计算机系统的作业吞吐量和系统效率。

2. 实验环境•操作系统：Linux•编程语言：Python•实验工具：CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节，主要负责将用户提交的作业按照一定的策略分配到CPU上执行。

作业调度的主要目标是提高CPU的利用率，缩短作业的平均等待时间，提高系统的吞吐量。

常用的作业调度算法有先来先服务（FCFS）、短作业优先（SJF）、最短剩余时间优先（SRT）等。

4. 实验内容本次实验主要分为两个部分：一是实现作业调度算法，二是对不同算法进行性能分析。

4.1 作业调度算法实现以先来先服务（FCFS）算法为例，实现作业调度如下：```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行，分析其性能指标，如平均等待时间、平均响应时间、吞吐量等。

C语言实现短作业优先调度算法

C语言实现短作业优先调度算法

#include "stdio.h"struct sjf{char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;float cckj;float yxtime;};sjf a[100];void input(sjf *p,int N){int i;printf("输入作业名& 到达时间&服务时间&存储空间:\n 例如: a 0 100 33\n");for(i=0;i<=N-1;i++){printf("输入第%d作业信息:\n",i+1);scanf("%s%f%f%f",&p[i].name,&p[i].arrivetime,&p[i].serviceti me,&p[i].cckj);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,float cckj,int N) {int k;printf("作业执行顺序:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\n作业信息:\n");printf("\nname\t arrive\t service\t start\t finish\t zz\t dqzz\t cckj\t ddsj\t yxtime\n");for(k=0;k<=N-1;k++){printf("%s\t %-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\t %-.2f\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].sta rttime,p[k].finishtime,p[k].zztime,p[k].dqzztime,p[k].cckj,p[k].finish time-p[k].servicetime,p[k].servicetime);}}//pai xuvoid sort(sjf *p,int N){for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//yun xing jieduanvoid deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,float cckj,int N){int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;} else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;} }for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzzt ime=0,cckj=0;sort(p,N);for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}float min=p[m+1].servicetime;int next=m+1;//m+1=nfor(int k=m+1;k<m+i;k++){if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztim e,cckj,N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzzti me,cckj,N);}void main(){int N;printf("********************************************** ******\n");printf(" 短作业优先调度算法\n");printf("********************************************** ******\n");printf("程序功能：输出作业序号--运行时间--存储空间--等待时间\n");printf("\n");printf("输入作业个数:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjff(b,N);}。

多级调度代码与结果截图

多级调度代码与结果截图

#include <iostream>using namespace std;#define T 7 //作业数#define T1 8#define A 3 //机器数extern void max_time(int m[][T1],int M1);extern void reveal(int m[][T1],int M1);extern void row_sum(int m[][T1],int M1);extern int min_time(int m[][T1],int M1);//将作业按占用的机器时间由大到小排序void sort(int n,int t[]){for (int i=0;i<n-1;i++){ for (int k=i;k<n;k++){if (t[i]<t[k]){int temp;temp = t[i];t[i] = t[k];t[k] = temp;}}}}void row_sum(int m[][T1],int M1){//并求出各个机器完成作业的时间，并将其分别存在二维数组每行的最后位置f or (int z=0;z<M1;z++) {m[z][T] = 0;for (int k=0;k<T;k++){if(m[z][k] == 0) break;elsem[z][T] = m[z][k] + m[z][T];}}}//显示每台机器调度的作业情况void reveal(int m[][T1],int M1){f or (int i=0;i<M1;i++){cout<<"第"<<i+1 <<"台机器完成的作业时间分别是："<<endl;for(int k=0;k<T;k++){if(m[i][k] == 0) break;elsecout<<m[i][k]<<" ";}cout<<endl;cout<<"花费的总时间是："<<m[i][T]<<endl;cout<<endl;}}//作业数小于机器数的调度的情况void set_work1(int M1,int m[][T1],int N,int n[]){f or (int i=0;i<N;i++)m[i][0] = n[i];r eveal(m,A);m ax_time(m,A);}//作业数大于机器数的调度的情况void set_work2(int M1,int m[][T1],int N,int n[]){f or (int i=0;i<N;i++){row_sum(m,M1);int temp = min_time(m,A);int num;int q;num = 0;//找到该机器调度的下一个作业应存放的位置for ( q=0;q<T;q++){if(m[temp][q] > 0) //该位置已存放作业num++; //则移动到该行的下一位置}m[temp][num] = n[i];m[temp][T] +=m[temp][num];}r eveal(m,A);m ax_time(m,A);}//寻找机器内已有作业共占用时间最少的机器序号int min_time(int m[][T1],int M1){i nt minTime = 0;for (int i=0;i<M1;i++){if (m[minTime][T] > m[i][T] )minTime = i;}return minTime;}//调度完成后求出机器内已有作业共占用时间最多的机器序号，//其完成作业的总时间即所有作业完成的时间void max_time(int m[][T1],int M1){i nt maxTime = m[0][T];f or (int i=0;i<M1;i++){if(maxTime < m[i][T])maxTime = m[i][T];}c out<<"所有作业均已完成的时间："<<maxTime<<endl;}void main(){i nt t[T] = {22,11,45,3,6,57,71};i nt m[A][T1] = {0,0};i nt i;c out<<"未排序的作业顺序为: ";f or(i=0;i<T;i++)cout<<t[i]<<" ";c out<<endl<<endl;s ort(T,t); //将作业按占用的机器时间由大到小排序c out<<"排序后的作业顺序为：";f or(i=0;i<T;i++)cout<<t[i]<<" ";cout<<endl;i f (A > T) //作业数小于机器数set_work1(A,m,T,t);e lseset_work2(A,m,T,t);}用户屏幕：。

批处理作业调度

批处理作业调度
2
t ji
tji 作业1 作业2 作业3
机器1业的6种可能的调度方案是1,2,3；1,3,2；2,1,3；2,3,1；3,1,2；3,2,1；它们所 相应的完成时间和分别是19，18，20，21，19，19。易见，最佳调度方案是1,3,2， 其完成时间和为18。
1
批处理作业调度
给定n个作业的集合{J1,J2,…,Jn}。每个作业必须先由机器1处理，然后由机器2处理。作业 Ji需要机器j的处理时间为tji。对于一个确定的作业调度，设Fji是作业i在机器j上完成处理 的时间。所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。 批处理作业调度问题要求对于给定的n个作业，制定最佳作业调度方案，使其完成时间 和达到最小。
批处理作业调度
•解空间：排列树 private static void backtrack(int i) { if (i > n) { for (int j = 1; j <= n; j++) bestx[j] = x[j]; bestf = f; } else for (int j = i; j <= n; j++) { f1+=m[x[j]][1]; f2[i]=((f2[i-1]>f1)?f2[i-1]:f1)+m[x[j]][2]; f+=f2[i]; public class FlowShop if (f < bestf) { static int n, // 作业数 MyMath.swap(x,i,j); f1, // 机器1完成处理时间 backtrack(i+1); f, // 完成时间和 MyMath.swap(x,i,j); bestf; // 当前最优值 } static int [][] m; // 各作业所需的处理时间 f1-=m[x[j]][1]; static int [] x; // 当前作业调度 f-=f2[i]; static int [] bestx; // 当前最优作业调度 } static int [] f2; // 机器2完成处理时间 }
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

源代码：#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0int n;float T1=0,T2=0;int times=0;struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t单道批处理作业调度系统\n");printf("\t\t*********************************************\t\t\n"); printf("\n\n\n\t\t\t\t\t09软件+电子商务2班\n");printf("\t\t\t\t\t\t黄才旺\n\n");printf("\n\n\n\t\t请按任意键进入主菜单：");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);getch();p->reachtime=i;printf("作业默认到达时间:%d",i);printf("\n输入作业需运行时间:");scanf("%d",&p->needtime);p->state='W';p->next=NULL;if(ready==NULL) ready=q=p;else{q->next=p;q=p;}}}void disp(JCB* q,int m) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况 {printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("\n 开始运行时刻 \t 完成时刻 \t 周转时间 \t 带权周转时间 \t相应比 \n");printf(" %d \t",q->starttime);printf(" %d \t",q->finishtime);printf(" %f \t",q->cycletime);printf(" %f\t",q->cltime);printf(" %f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("\n 开始运行时刻 \t 完成时刻 \t 周转时间 \t 带权周转时间 \n");printf(" %d \t",q->starttime);printf(" %d \t",q->finishtime);printf(" %f \t",q->cycletime);printf(" %f\t",q->cltime);getch();}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来{ready=p->next;p->next=NULL;}else{q=ready;while(q->next!=p) q=q->next;q->next=p->next;}p->starttime=times;//计算作业运行后的完成时间,周转时间等等 p->state='R';p->finishtime=p->starttime+p->needtime;p->cycletime=(float)(p->finishtime-p->reachtime);p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况 times+=p->needtime;p->state='F';printf("\n%s 作业已完成!\n请按任意键继续...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比{JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/padv->n eedtime;padv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是：%f",n,t);printf("\n%d个作业的平均带权周转时间是：%f\n\n\n",n,s);}void hrn(int m) //高响应比算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p; p=p->next;}while(p!=NULL);if(iden){i--;times++;if(times>1000){printf("\nruntime is too long...error...");getch();} }else{running(min,m); //调用running()函数 }} //forfinal(); //调用running()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--;times++;if(times>100){printf("\nruntime is too long...error");getch();} }else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数}void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0;if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用running()函数}void mune(){int m;system("cls");printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t作业调度主菜单\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t\t1.先来先服务算法");printf("\n\t\t\t2.最短作业优先算法");printf("\n\t\t\t3.响应比高者优先算法");printf("\n\t\t\t0.退出程序");printf("\n\n\t\t\t\t选择算法:");scanf("%d",&m);switch(m){case 1:fcfs(m);getch();system("cls");mune();break;case 2:sjf(m);getch();system("cls");mune();break;case 3:hrn(m);getch();system("cls");mune();break;case 0:system("cls");break;default:printf("选择错误,重新选择.");getch();system("cls");mune();}}main() //主函数{inize();mune();}选择1进入“先来先服务算法”作业调度：选择2进入“最短作业优先算法”作业调度：选择3进入“响应比高者优先算法”作业调度：。

相关文档
最新文档