作业调度算法C++实现

合集下载

操作系统第二章习题

第二章练习题及参考答案一、单项选择题1.用户作业可以通过（）方式由用户自己按照作业来进行操作。

A.脱机B.自动控制C.在线处理D.联机处理2.（）是操作系统提供的一种专门语言，它由操作系统的专门机制解释处理。

A.C语言B.JCL语言C.Ada语言D.Pascal语言3.作业调度算法中（）调度算法最有利于提高资源利用率。

A.先来先服务B.优先数C.响应比最高优先D.均衡4.终端用户在终端上控制作业的执行要经历四个阶段，最初阶段是（）。

A.用户注册B.终端连接C.作业控制D.用户退出5.在下面作业调度算法中（）调度算法最有利于小作业，从而提高系统吞吐能力。

A.先来先服务B.计算时间短的作业优先C.优先数D.响应比最高者优先6.当中央处理器处于目态时，它可以执行的指令是（）。

A.计算机系统中的全部指令B.仅限于非特权指令C.仅限于防管指令D.仅限于特权指令7.作业调度算法常考虑因素之一是使系统有最高的吞吐率，为此应（）。

A.不让处理机空闲B.能够处理尽可能多的作业C.使各类用户满意D.不使系统过于复杂8. 分时操作系统环境下运行的作业通常称为（）。

A.后台作业B.长作业C.批量型作业D.终端型作业9.在作业调度算法中，若所有作业同时到达，则平均等待时间最短的算法是（）。

A.先来先服务B.优先数C.响应比最高优先D.计算时间段的作业优先10.作业调度程序从处于（）状态的作业队列中选取适当的作业投入运行。

A.执行B.提交C.完成D.后备11.既考虑作业等待时间，又考虑作业执行时间的调度算法是（）。

A. 先来先服务B.优先数C.响应比最高优先D.均衡12.（）是指从作业提交给系统到作业完成的时间间隔。

A.周转时间B.响应时间C.等待时间D.执行时间13.作业从进入后备队列到被调度程序选中的时间间隔称为（）。

A.周转时间B.响应时间C.等待时间D.触发时间二、多项选择题1.响应比最高者优先调度算法是（）调度算法的折衷。

先来先服务和优先数调度算法c语言

先来先服务和优先数调度算法c语言先来先服务和优先数调度算法c语言一、前言操作系统中的进程调度是指在多道程序环境下，按照一定的规则从就绪队列中选择一个进程，将CPU分配给它运行。

常用的进程调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。

本文将介绍两种常见的进程调度算法：先来先服务和优先数调度算法，并给出相应的C语言实现。

二、先来先服务算法1. 算法原理FCFS即First Come First Served，也称为FIFO（First In First Out），是一种非抢占式的进程调度算法。

按照任务到达时间的顺序进行处理，即谁先到达谁就被处理。

2. 算法流程（1）按照任务到达时间排序；（2）依次执行每个任务，直至所有任务都完成。

3. C语言实现下面是一个简单的FCFS程序：```c#include <stdio.h>struct process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间int waiting_time; // 等待时间};int main() {struct process p[10];int n, i, j;float avg_waiting_time = 0;printf("请输入进程数：");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第%d个进程的信息：\n", i + 1); printf("进程ID：");scanf("%d", &p[i].pid);printf("到达时间：");scanf("%d", &p[i].arrival_time);printf("执行时间：");scanf("%d", &p[i].burst_time);}for (i = 0; i < n; i++) {for (j = 0; j < i; j++) {if (p[j].arrival_time > p[j + 1].arrival_time) { struct process temp = p[j];p[j] = p[j + 1];p[j + 1] = temp;}}}int current_time = p[0].arrival_time;for (i = 0; i < n; i++) {if (current_time < p[i].arrival_time) {current_time = p[i].arrival_time;}p[i].waiting_time = current_time - p[i].arrival_time;current_time += p[i].burst_time;}printf("进程ID\t到达时间\t执行时间\t等待时间\n");for (i = 0; i < n; i++) {printf("%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, p[i].waiting_time);avg_waiting_time += (float)p[i].waiting_time / n;}printf("平均等待时间：%f\n", avg_waiting_time);return 0;}```三、优先数调度算法1. 算法原理优先数调度算法是一种非抢占式的进程调度算法。

操作系统单选题

一、单项选择题（每小题1分，共15分）1．MS-DOS的引导程序是在磁盘初始化时，由（）命令写在软盘或硬盘的0柱0面1扇区上的。

A．CHKDSKB．FDISKC．FORMATD．DISKCOPY2．MS-DOS 5．0开始把（）的内存区域作为基本内存区。

A．1MB与2MB之间B．1MB之后C．640KB与1MB之间D．0KB与640KB之间3．MS-DOS中的文件存储结构采用（）。

A．顺序结构B．链接结构C．索引结构D．成组链接结构4．与“计算时间”无关的作业调度算法是（）算法。

A．先来先服务B．响应比高者优先C．优先数D．可抢占的优先数5．实时系统中的进程调度通常采用（）算法。

A．响应比高者优先B．短作业优先C．时间片轮转D．抢占式的优先数高者优先6．在可变分区存储管理中，为了实现主存的空间分配，应设置（）来进行管理。

A．页表B．段表C．位示图D．空闲区表7．某系统有同类资源m个供n个进程共享，如果每个进程最多申请k个资源（1＜=k＜=m），则各进程的最大需求量之和（）时系统不会发生死锁。

A．＝mB．＝m+nC．＜m十nD．＞m+n8．动态重定位是在（）完成的。

A．作业执行前B．作业执行过程中由硬件C．作业执行过程中由OSD．作业执行过程中由用户9．Windows操作系统是由（）公司研制的。

A．MicrosoftB．IntelC．HPD．SUN SYSTEM10．进程从等待状态进人就绪状态可能是由于（）。

A．现运行进程运行结束B．现运行进程执行P操作C．现运行进程执行了V操作D．现运行进程时间片用完11．在以下的存储管理方案中，能扩充主存容量的是（）。

A．固定式分区管理B．可变式分区管理C．页式存储管理D．分页虚拟存储管理12．UNIX文件系统对盘空间的管理采用（）。

A．FAT表法B．位示图法C．空闲块链接法D．空闲块成组链接法13．通道在输人输出操作完成或出错时就形成（），等候CPU来处理。

调度算法C语言实现

调度算法C语言实现调度算法是操作系统中的重要内容之一，它决定了进程在系统中的运行方式和顺序。

本文将介绍两种常见的调度算法，先来先服务（FCFS）和最短作业优先（SJF），并用C语言实现它们。

一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度，即谁先到达就先执行。

实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。

下面是一个用C语言实现先来先服务调度算法的示例程序：```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量：");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间：", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间：%f\n", avgWaitingTime);printf("平均周转时间：%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务（FCFS）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。

操作系统选择题

一、选择1、操作系统的基本类型主要有____C______。

A、批处理系统、分时系统和多任务系统D、实时系统、分时系统和多用户系统2、操作系统的_____D_____管理部分负责对进程进行调度。

A、存储器B、文件C、设备3___B_____，则响应时间越长。

A、用户数越少C、内存越少D、内存越多4、实时系统追求的目标是______C____A、充分利用内存B、高吞吐率D、减少系统开销5______A____。

充分利用CPU，减少CPU等待时间B、提高实时响应速度C、有利于代码共享，减少主、辅存信息交换量D、充分利用存储器6、现代操作系统的基本特征是_____C______、资源共享和操作的异步性。

A、.多道程序设计B、中断处理D、实现分时与实时处理7、以下___C_____A、内存管理B、中断处理D、CPU调度8、如果分时系统中的时间片一定，用户数的多少与响应时间长短成__A__。

A、正比例B、反比例C、无正常比例关系D、呈线型关系9、三种基本类型的操作系统是____B____。

C、分时操作系统、实时操作系统和网络操作系统D、实时操作系统、网络操作系统和批处理操作系统10、不属于．．．单道．．批处理系统所具备的特征是____D____。

A、单道性B、顺序性C、自动性11。

A、时问片轮转调度算法C、先来先服务调度算法D、分级调度算法12_____A_____。

CPU，减少CPU等待时间B、提高实时响应速度C、有利于代码共享，减少主、辅存信息交换量D、充分利用存储器13、现代操作系统的基本特征是并发、_____D______和操作的异步性。

A、多道程序设计B、中断处理C、及时处理14、操作系统的类型按时间发展顺序，可分为______C____。

A、分时系统、批处理系统、实时系统D、实时系统、分时系统、批处理系统15. 下列哪一条不是批处理系统的优点？______D____A. 吞吐量大B. 资源利用率高C. 系统开销小16. UNIX 属于下列哪一类操作系统？___C____A. 单用户单任务B. 单用户多任务 D. 批处理17. 以下那个不是程序顺序执行的特性（C ）Ａ、封闭性Ｂ、顺序性Ｄ、不可再现性18. Windows NT属于哪一类操作系统？__DA、单用户单任务C、单道批处理1、如果信号量S的值是0，此时进程A执行P(S)操作，则进程A会__B ______。

进程调度算法实验报告

操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。

实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。

设计分析：程序流程图：1.先来先服务算法2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <iostream.h>#define n 20typedef struct{int id; //进程名int atime; //进程到达时间int runtime; //进程运行时间}fcs;void main(){int amount,i,j,diao,huan;fcs f[n];cout<<"请输入进程个数:"<<endl;cin>>amount;for(i=0;i<amount;i++){cout<<"请输入进程名，进程到达时间，进程运行时间:"<<endl; cin>>f[i].id;cin>>f[i].atime;cin>>f[i].runtime;}for(i=0;i<amount;i++) //按进程到达时间的先后排序{ //如果两个进程同时到达，按在屏幕先输入的先运行for(j=0;j<amount-i-1;j++){ if(f[j].atime>f[j+1].atime){diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在"<<f[i].atime+f[i].runtime<<"之前结束。

c语言实现进程调度算法

c语言实现进程调度算法进程调度算法是操作系统中的一个重要组成部分，用于决定在多道程序环境下，选择哪个进程来占用CPU并执行。

C语言是一种通用的编程语言，可以用于实现各种进程调度算法。

这里我将分别介绍三种常见的进程调度算法：先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）和轮转法调度算法（RR），并给出用C语言实现的示例代码。

首先，我们来看先来先服务调度算法（FCFS）。

此算法根据到达时间的先后顺序，按照先来后到的顺序进行处理。

下面是基于C语言的先来先服务调度算法实现示例代码：```c#include<stdio.h>struct Process};void FCFS(struct Process proc[], int n)for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}FCFS(proc, n);return 0;```其次，我们来看最短作业优先调度算法（SJF），该算法选择执行时间最短的进程先执行。

下面是基于C语言的最短作业优先调度算法实现示例代码：```c#include<stdio.h>struct Process};void SJF(struct Process proc[], int n)for (int i = 0; i < n; i++)for (int j = 0; j < i; j++)}shortest_job = i;for (int j = i + 1; j < n; j++)shortest_job = j;}}}for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}SJF(proc, n);return 0;```最后，我们来看轮转法调度算法（RR），该算法分配一个时间片给每个进程，当时间片用完后，将CPU分配给下一个进程。

作业调度

作业调度：从输入井中选中后备作业装入主存储器的过程，称为作业调度进程调度：从就绪队列中选中一个进程占用处理器运行作业调度的必要条件：系统现有尚未分配的资源可以满足被选中作业的资源要求。

作业调度算法的原则：公平性、平衡资源使用、极大的流量作业调度算法1、先来先服务算法按照作业进入输入井的先后次序来挑选作业，进入的作业优先被选中。

但是要注意，不是先进入的一定被选中，只有满足“必要条件”的作业才可能被选中。

一个先进入的作业，如果它所需要的资源或其中一部分资源已被在它先前的作业占用且尚未归还，那么这个作业将被推迟，而去选择在它之后进入的资源能满足的作业。

一旦有作业执行结束归还了资源后，作业调度再次选择作业时，仍要按照进入输入井的次序去挑选，刚刚被推迟的作业有可能被优先选中。

例子：假设用户使用的主存空间为100KB，作业调度和进程调度均采用先来先服务算法，进入输入井时间如下表：当作业调度是，A,B作业首先依次被选中装入主存，但作业C到达输入井后，由于不能满足它对主存量的要求，只能让它在输入井中等待，对随后到达输入井的作业D和E，作业D的主存需求可以得到满足，于是选中D装入主存。

于是A,B,C 总共占用85KB主存，还剩余15KB的空闲区，不够装入作业E，因此C,E均被推迟，在输入井中等待。

随后A被执行完，释放了15KB的主存，目前存储器有两个15KB的空闲区，仍不能装入C或E。

随后在11.3刻时间，B执行完，释放60K 的主存空间和A作业释放的15KB合并后成75KB的空闲区。

满足C和E的需求，因此C,E在11.3刻同时被装入主存。

优点：算法简单容易实现，具有一定的公平性缺点计算时间短的作业可能周转时间很长，从而增加了系统平均周转时间，降低了系统的吞吐率2、计算时间短的作业优先算法作业调度根据在输入井中的作业提出的计算时间为标准，优先选择计算时间短且资源能得到满足的作业。

由于作业是依次进入输入井的，所以该算法仍将像先来先服务算法一样，会依次把作业A,B,D先装入主存，调度进程按装入的次序让他们依次占用处理器。

【操作系统】先来先服务和短作业优先算法（C语言实现）

【操作系统】先来先服务和短作业优先算法（C语⾔实现）【操作系统】先来先服务算法和短作业优先算法实现介绍:1.先来先服务 (FCFS: first come first service)如果早就绪的进程排在就绪队列的前⾯，迟就绪的进程排在就绪队列的后⾯，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之⾸的那个进程调度到运⾏状态。

也就说，它只考虑进程进⼊就绪队列的先后，⽽不考虑它的下⼀个CPU周期的长短及其他因素。

FCFS算法简单易⾏，是⼀种⾮抢占式策略，但性能却不⼤好。

简单来说，先来先服务就是那个进程到达时间最早，那么CPU就先处理哪个进程。

2.短作业优先（SJF, Shortest Job First）对预计执⾏时间短的作业（进程）优先分派处理机。

通常后来的短作业不抢先正在执⾏的作业。

也就是说，不但要考虑进程的到达时间，还要考虑进程需要运⾏的时间。

当⼀个进程正在运⾏时，假如有其他的进程到达，那么这些到达的进程就需要按照其需要运⾏的时间长短排序，运⾏时间短的在前，运⾏时间长的在后。

3.例⼦：4.运⾏截图1.先来先服务2.短作业优先5.话不多说，直接上代码。

第⼀次写，有很多不⾜的地⽅。

希望⼤家看到可以帮忙纠正⼀下，谢谢⼤家。

#include <stdio.h>#include <stdlib.h>#define MAX 10typedef struct PCB {int id,arrive_time,service_time,start_time,finish_time; //进程id、到达时间、服务时间、开始时间、完成时间float zhouzhuan_time,daiquanzhouzhuan_time; //周转时间、带权周转时间。

只能说我的拼英。

emm，。

尴尬。

int status;}PCB;typedef enum {OK,ERROR}Status;typedef enum {FALSE,TRUE}Bool;typedef PCB datatype;typedef struct LinkQueue {int front;int rear;int length;datatype* base;}quene;int arrive[MAX]; // 记录每个作业的到达时间int service[MAX]; //记录每个作业的服务时间int num; //输⼊的进程个数quene init(){quene q_pcb;q_pcb.base = (datatype *)malloc(sizeof(datatype)*MAX);q_pcb.front = q_pcb.rear = 0;q_pcb.length = 0;return q_pcb;}Bool isFull(quene *q) {if ((q->rear + 1) % MAX == q->front) {return TRUE;}return FALSE;}Bool isEmpty(quene *q) {if (q->rear == q->front) {return TRUE;}return FALSE;}Status rudui(quene *q,datatype p){ //⼊队。

操作系统习题及解答

第一章绪论一、单项选择题1、在下列选择中，（D）不是操作系统关心的主要问题。

A、管理计算机裸机B、设计、提供用户程序计算机硬件系统的界面C、管理计算机系统资源D、高级程序设计语言的编译器2、批处理系统的主要缺点是（C）。

A、CPU利用率低B、不能并发执行C、缺少交互性D、以上都不是3、多道程序设计是指（D）。

A、在实时系统中并发运行多个程序B、在分布系统中同一时刻运行多个程序C、在一台处理器上同一时刻运行多个程序D、在一台处理器上并发运行多个程序4、以下最早的OS是（D）。

A、分布式系统B、实时系统C、分时系统D、批处理系统5、批处理OS提高了计算机系统的工作效率，但（D）。

A、不能自动选择作业执行B、无法协调资源分配C、不能缩短作业执行时间D、在作业执行时用户不能直接干预6、分时OS追求的目标是（C）。

A、高吞吐量B、充分利用内存C、快速响应D、减少系统开销7、多道批处理系统提高了计算机系统的资源利用率，同时（B）A、减少了各作业的执行时间B、增加了作业吞吐量C、减少了作业的吞吐量D、减少了部分作业的执行时间8、设计实时OS时，（B）不是主要追求目标。

A、安全可靠B、资源利用率C、及时响应D、快速处理9、现代OS的两个基本特征是（C）和资源共享。

A、多道程序设计B、中断处理C、程序的并发执行D、实现分时与时实处理10、OS中采用多道程序设计技术提高了CPU和外部设备的（A）。

A、利用率B、可靠性C、稳定性D、兼容性11、OS的基本类型有（B）A、批处理系统、分时系统及多任务系统B、实时OS、批处理OS及分时OSC、单用户系统、多用户系统及批处理系统D、实时系统、分时系统和多用户系统12、为了使系统中所有的用户都能得到及时响应，该OS应该是（B）A、多道批处理系统B、分时系统C、实时系统D、网络系统13、从下列叙述中选出正确的叙述（A）。

A、OS的不确定性是指在OS控制下的多个作业执行顺序和每个作业的执行时间是不确定的。

(完整word版)操作系统作业调度实验报告-多道批处理

计算机学院计算机科学与技术专业07 班姓名学号教师评定_________________实验题目作业调度一、实验目的本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。

二、实验内容和要求1、为单道批处理系统设计一个作业调度程序(1)、编写并调试一个单道处理系统的作业调度模拟程序。

(2)、作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）的调度算法。

(3)、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。

(4)、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。

每个作业的最初状态总是等待W。

(5)、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。

2、模拟批处理多道操作系统的作业调度（1）写并调试一个作业调度模拟程序。

（2）作业调度算法：分别采用先来服务（FCFS）调度算法。

（3）在批处理系统中，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求，所需要的资源是否得到满足。

作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理机运行。

作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。

但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业要求，那么，作业调度必须按一定的算法在这些作业中作出选择。

国开形成性考核02152《操作系统》形考作业(2)试题及答案

国开形成性考核《操作系统》形考作业(2)试题及答案（课程ID：02152，整套相同，如遇顺序不同，Ctrl+F查找，祝同学们取得优异成绩！）形考作业2一、单选题（每题4分，共计16题）题目：1、按照作业到达的先后次序调度作业，排队等待时间最长的作业被优先调度，这是指（C）调度算法。

【A】：优先级法【B】：短作业优先法【C】：先来先服务法【D】：时间片轮转法题目：2、为了使系统中各部分资源得到均衡使用，就必须选择对资源需求不同的作业进行合理搭配，这项工作是由（C）完成的。

【A】：中级调度【B】：对换【C】：作业调度【D】：进程调度题目：3、在操作系统中，作业处于（B）状态时，已处于进程的管理之下。

【A】：阻塞【B】：执行【C】：后备【D】：完成题目：4、当硬件中断装置发现有事件发生，就会中断正在占用CPU的程序执行，让操作系统的（C）占用CPU。

【A】：文件管理程序【B】：作业管理程序【C】：中断处理程序【D】：系统调用程序题目：5、为了对紧急进程或重要进程进行调度，调度算法应采用（B）。

【A】：短作业优先法【B】：优先级法【C】：先来先服务法【D】：时间片轮转法题目：6、作业调度选择一个作业装入主存后，该作业能否占用处理器必须由（B）来决定。

【A】：作业控制【B】：进程调度【C】：驱动调度【D】：设备管理题目：7、在作业调度中，若采用优先级调度算法，为了尽可能使CPU和外部设备并行工作，有如下三个作业：J1以计算为主，J2以输入输出为主，J3计算和输入输出兼顾，则它们的优先级从高到低的排列顺序是（D）。

【A】：J2，J3，J1【B】：J2，J1，J3【C】：J1，J2，J3【D】：J3，J2，J1题目：8、最容易形成很多小碎片的可变分区算法是（C）。

【A】：最先适应算法【B】：以上都不是【C】：最佳适应算法【D】：位示图法题目：9、下列存储管理方案中，不采用动态重定位的是（C）。

【A】：段式管理【B】：可变分区【C】：固定分区【D】：页式管理题目：10、虚拟存储技术是（C）。

C++程序流水作业调度

T ' ( S , t ) t[i,1] t[ j ,1] T ( S {i, j}, t ji ) 。
其中， t ji t[ j,2] t[i,2] t[ j,1] t[i,1] max{t , t[i,1] t[ j,1] t[ j,2], t[ j,1]} 当作业 i 和 j 满足 Johnson 不等式 min{t[i,2], t[ j,1]} min{t[ j,2], t[i,1]} 时，我们有 max{t[i,2],t[ j,1]} max{t[ j,2],t[i,1]} 从而， t[i,1] t[ j,1] max{t[i,2],t[i,1]} t[i,1] t[ j,1] max{t[ j,2],t[i,1]} 由此可得， max{t[i,1] t[ j,1] t[i,2], t[i,1]} max{t[i,1] t[ j,1] t[ j,2], t[i,1]} 因此任意 t 有
4. 算法的描述
从上面的分析可知，流水作业调度问题一定存在满足 Johnson 法则的最优调度，且容易由下面的算法确定。流水作业调度问题的 Johnson 算法：（1）令 N1 {i | t[i,1] t[i,2]}, N2 {i | t[i,1] t[i,2]} ；（2）将 N1 中作业依 t[i,1] 的非减序排列；将 N 2 中作业依 t[i,2] 的非增序排列；（3） N1 作业接 N 2 种作业构成满足 Johnson 法则的最优调度。具体的代码在文件夹《流水作业调度——动态规划法》文件夹中。三、时空效率分析算法 FlowJob 的主要计算时间花在对作业集的排序上。在这里，我们使用冒泡排序法(BubbleSort)，因此，在最坏情况下算法 FlowJob 所需要的计算时间为 O(n log n) 。所需要的空闲显然是 O(n) 。

处理器调度算法c语言

处理器调度算法c语言一、概述处理器调度算法是操作系统中一个非常重要的问题。

在多任务操作系统中，有多个进程同时运行，而处理器只有一个，因此需要对进程进行调度，使得每个进程都能够得到适当的执行时间。

二、常见的处理器调度算法1. 先来先服务（FCFS）FCFS算法是最简单的调度算法之一。

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

这种算法容易实现，但可能会导致长作业等待时间过长。

2. 最短作业优先（SJF）SJF算法是根据每个进程所需的CPU时间来进行排序，并按照顺序进行调度。

这种算法可以减少平均等待时间和平均周转时间，并且可以最大限度地利用CPU资源。

3. 优先级调度优先级调度是根据每个进程的优先级来进行排序，并按照顺序进行调度。

这种算法可以确保高优先级进程得到更多的CPU时间，但可能会出现低优先级进程饥饿问题。

4. 时间片轮转（RR）RR算法将CPU分配给每个任务一定量的时间片，在该时间片内运行任务。

如果任务在该时间片内未完成，则将其放回队列尾部，并分配给下一个任务时间片。

这种算法可以确保公平性，并且可以避免长作业等待时间过长。

三、C语言中的处理器调度算法实现1. FCFS算法实现#include <stdio.h>int main(){int n, i, j;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}2. SJF算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0; printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n]; printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(burst_time[i] > burst_time[j]){temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}3. 优先级调度算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n], priority[n];printf("Enter the burst time and priority for each process:\n"); for(i=0; i<n; i++)scanf("%d %d", &burst_time[i], &priority[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(priority[i] > priority[j]){temp = priority[i];priority[i] = priority[j];priority[j] = temp;temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround_ time += turnaround_ time[i];}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", i+1, burst_ time[i], priority[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}4. RR算法实现#include <stdio.h>int main(){int n, i, j, time_quantum;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], remaining_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);printf("Enter the time quantum: ");scanf("%d", &time_quantum);for(i=0; i<n; i++)remaining_time[i] = burst_time[i];int t=0;while(1){int done = 1;for(i=0; i<n; i++){if(remaining_time[i] > 0){done = 0;if(remaining_ time[i] > time_ quantum){t += time_ quantum;remaining_ time[i] -= time_ quantum;}else{t += remaining _ time[i];waiting_time[i] = t - burst_time[i];remaining_ time[i] = 0;turnaround_ time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround _ time += turnaround_ time[i];}}}if(done == 1)break;}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}四、总结以上是常见的处理器调度算法的C语言实现方式。

c语言编写的进程调度算法

c语言编写的进程调度算法C语言编写的进程调度算法进程调度是操作系统的核心功能之一，它负责按照一定的策略和算法，合理地分配CPU资源给正在运行或即将运行的进程，从而提高操作系统的性能和资源利用率。

在操作系统中，存在多种不同的进程调度算法，本文将以C语言编写进程调度算法为主题，一步一步回答。

第一步：定义进程结构体首先，我们需要定义一个进程的数据结构体，以便在调度算法中使用。

进程结构体包括进程ID、进程优先级、进程状态等信息。

以下是一个简单的进程结构体示例：ctypedef struct {int pid; 进程IDint priority; 进程优先级int state; 进程状态} Process;第二步：初始化进程队列进程队列是存储所有待调度进程的数据结构，可以使用链表或数组来实现。

在初始化进程队列之前，需要先创建一个空的进程队列。

以下是一个简单的初始化进程队列函数：c#define MAX_PROCESSES 100 最大进程数Process processQueue[MAX_PROCESSES]; 进程队列int processCount = 0; 当前进程数void initProcessQueue() {processCount = 0;}第三步：添加进程到队列在调度算法中，需要将新创建或运行的进程添加到进程队列中，这样才能对其进行调度。

以下是一个简单的添加进程到队列的函数：void addProcess(int pid, int priority, int state) {if (processCount >= MAX_PROCESSES) {printf("进程队列已满，无法添加进程！\n");return;}Process newProcess;newProcess.pid = pid;newProcess.priority = priority;newProcess.state = state;processQueue[processCount] = newProcess;processCount++;}第四步：实现进程调度算法进程调度算法决定了操作系统如何决定哪个进程应该被调度并获得CPU 资源。

(完整版)操作系统短作业优先调度算法汇总,推荐文档

3
五、主要数据结构及其说明
算法的基本概念和原理：本次课程设计主要是采用短作业优先算法进程的进程调度过程。短作业优先调度算法，是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。因此，在要求比较严格的实时系统中，不宜采用这种调度方式。本课程设计主要是在满足要求多道单处理机的情况下进行短作业的优先调度。
4
达的，那么首先执行该进程；之后就比较进程的服务时间，谁的服务时间短就先执行谁（如果服务时间相同则看它们的到达时间，到达时间短的先执行）；如果到达时间和服务时间相同，则按先来先服务算法执行。
六、程序运行结果
1 进入操作界面如下 2 输入进程的信息
3 各时刻进程的状态
5
6
4 进程信息
5 平均带权周转时间界面
float run_time;
run_time=Process[i].WholeTime;
j=1;
while((j<N)&&(Process[i].ArrivalTime==Process[j].ArrivalTime)) //判断是

FCFS，SJF，HRRN算法实现作业调度

FCFS，SJF，HRRN算法实现作业调度实验原理（1）定义程序控制块的结构体和程序⼯作时间的结构体，JCB可以包含以下信息：作业名、提交（到达）时间、所需的运⾏时间、所需的资源、作业状态、链指针等等。

程序⼯作时间包括作业运⾏时刻，作业完成时刻，周转时间，带权周转时间。

（2）主程序默认采⽤的算法是先来先服务，当选择另外两种算法时通过主程序去调⽤这种作业调度算法，分别是SJF，HRN。

（3）通过构造进程输⼊input()，进程运⾏结果输出output()，disp(),以及使整个程序正常运⾏的函数块等，通过主函数调⽤⽅法函数的想法来实现作业调度。

（4）在对程序控制块的访问和调⽤通过链表指针的形式，进⾏调⽤各种作业调度算法。

在作业输⼊后，会显⽰输⼊的内容，并把每⼀个作业运⾏的状态都能在程序中体现出来。

1 #include<stdio.h>2 #include <stdlib.h>3 #include <conio.h>4#define getpch(type) (type*)malloc(sizeof(type)) //为进程创建⼀个空间56struct worktime{7float Tb; //作业运⾏时刻8float Tc; //作业完成时刻9float Ti; //周转时间10float Wi; //带权周转时间11 };1213struct jcb {14char name[10]; //作业名15float arrivetime; //作业到达时间16float runtime; //作业所需的运⾏时间17char resource; //所需资源18float Rp; //后备作业响应⽐19char state; //作业状态20int worked_time; //已运⾏时间21struct worktime wt;22int need_time; //需要运⾏的时间23int flag; //进程结束标志24struct jcb* link; //链指针25 }*ready=NULL,*p;2627 typedef struct jcb JCB;//重命名结构体28float T=0;29int N;30 JCB *front,*rear;3132void sort()33 {34 JCB *first, *second;35int insert=0; //插⼊数36if((ready==NULL)||((p->arrivetime)<(ready->arrivetime)))37 {38 p->link=ready;39 ready=p;40 T=p->arrivetime;41 p->Rp=1;42 }43else44 {45 first=ready;46 second=first->link;47while(second!=NULL)48 {49if((p->arrivetime)<(second->arrivetime))50 {51 p->link=second;52 first->link=p;53 second=NULL;54 insert=1;55 }56else57 {58 first=first->link;59 second=second->link;60 }61 }62if (insert==0) first->link=p;63 }64 }6566void SJFget()67 {68 JCB *front,*mintime,*rear;69int ipmove=0;70 mintime=ready;71 rear=mintime->link;72while(rear!=NULL)73 {74if ((rear!=NULL)&&(T>=rear->arrivetime)&&(mintime->runtime)>(rear->runtime))75 {76 front=mintime;77 mintime=rear;78 rear=rear->link;79 ipmove=1;80 }81else82 rear=rear->link;83 }84if (ipmove==1)85 {86 front->link=mintime->link;87 mintime->link=ready;88 }89 ready=mintime;90 }9192void HRNget()93 {94 JCB *front,*mintime,*rear;95int ipmove=0;96 mintime=ready;97 rear=mintime->link;98while(rear!=NULL)99if ((rear!=NULL)&&(T>=rear->arrivetime)&&(mintime->Rp)<(rear->Rp))100 {101 front=mintime;102 mintime=rear;103 rear=rear->link;104 ipmove=1;105 }106else107 rear=rear->link;108if (ipmove==1){109 front->link=mintime->link;110 mintime->link=ready;111 }112 ready=mintime;113 }114115void creatJCB() //为每个作业创建⼀个JCB并初始化形成⼀个循环链队列116 {117 JCB *p,*l;118int i=0;119 l = (JCB *)malloc(sizeof(JCB));120 printf("\n 请输⼊作业的个数:");121 scanf("%d",&N);122 printf("\n 作业号No.%d:\n",i);123 printf("\n请输⼊作业的名字:");124 scanf("%s",l->name);125 printf("\n请输⼊作业需要运⾏的时间:");126 scanf("%d",&l->need_time);127 l->state = 'r'; //作业初始状态为就绪(即准备状态)128 l->worked_time = 0;129 l->link=NULL;130 l->flag=0;131 front=l;132for(i =1;i<N;i++)133 {134 p = (JCB *)malloc(sizeof(JCB));135 printf("\n 作业号No.%d:\n",i);136 printf("\n请输⼊作业的名字:");137 scanf("%s",p->name);138 printf("\n请输⼊作业的时间:");139 scanf("%d",&p->need_time);140 p->state='r';141 p->worked_time=0;142 p->flag=0;143 l->link=p;144 l=l->link;145 }146 rear=l;rear->link=front;147 }148149void output()//进程输出函数150 {151int j;152 printf("name runtime needtime state\n");153for(j=1;j<=N;j++)154 { printf(" %-4s\t%-4d\t%-4d\t%-c\n",front->name,front->worked_time,front->need_time,front->state);155 front=front->link;156 }157 printf("\n");158 }159160int judge(JCB *p) //判断所有进程运⾏结束161 {162int flag=1,i;163for(i=0;i<N;i++)164 {165if(p->state!='e')166 {167 flag = 0;168break;}169 p=p->link;170 }171return flag;172 }173174//作业输⼊175void input()176 {177int i,num;178 printf("\n 请输⼊作业的个数:");179 scanf("%d",&num);180for(i=0;i<num;i++)181 {182 printf(" 作业号No.%d:\n",i);183 p=getpch(JCB);184 printf(" 输⼊作业名:");185 scanf("%s",p->name);186 printf(" 输⼊作业到达时刻:");187 scanf("%f",&p->arrivetime);188 printf(" 输⼊作业运⾏时间:");189 scanf("%f",&p->runtime);190 printf("\n");191 p->state='w';192 p->link=NULL;193 sort();194 }195 }196197int space()198 {199int l=0; JCB* jr=ready;200while(jr!=NULL)201 {202 l++;203 jr=jr->link;204 }205return(l);206 }207208void disp(JCB* jr,int select)209 {210if (select==3) printf("\n 作业到达时间服务时间响应⽐运⾏时刻完成时刻周转时间带权周转时间 \n"); 211else printf("\n 作业到达时间服务时间运⾏时刻完成时刻周转时间带权周转时间 \n");212 printf(" %s\t",jr->name);213 printf("%.2f\t ",jr->arrivetime);214 printf("%.2f\t",jr->runtime);215if (select==3&&p==jr) printf(" |%.2f ",jr->Rp);216if (p==jr){217 printf(" %.2f\t",jr->wt.Tb);218 printf(" %.2f ",jr->wt.Tc);219 printf(" %.2f\t",jr->wt.Ti);220 printf(" %.2f",jr->wt.Wi);221 }222//printf("\n");223 }224225int destroy()226 {227free(p);228return(1);229 }230231void check(int select)232 {233 JCB* jr;234 printf(" 是 :%s",p->name);//当前执⾏的作业是235 disp(p,select);236 jr=ready;237 destroy();238 }239240void running(JCB* jr)241 {242if (T>=jr->arrivetime) jr->wt.Tb=T;243else jr->wt.Tb=jr->arrivetime;244 jr->wt.Tc=jr->wt.Tb+jr->runtime;245 jr->wt.Ti=jr->wt.Tc-jr->arrivetime;246 jr->wt.Wi=jr->wt.Ti/jr->runtime;247 T=jr->wt.Tc;248 }249250int main()251 {252int select=0,len,h=0;253float sumTi=0,sumWi=0;254 printf("请选择作业调度算法的⽅式:\n");255 printf("\t1.FCFS 2.SJF 3.HRN \n");256 printf("请输⼊作业调度算法序号(1-3):");257 scanf("%d",&select);258259 input(); //调⽤输⼊函数260 len=space();261262263while((len!=0)&&(ready!=NULL))264 {265 h++;266 printf(" 第%d个执⾏作业 ",h);267 p=ready;268 ready=p->link;269 p->link=NULL;270 p->state='R';271 running(p);272 sumTi+=p->wt.Ti;273 sumWi+=p->wt.Wi;274 check(select); //与所选择的算法⽐较，调⽤void check(int select)275if (select==2&&h<len-1) SJFget();276if (select==3&&h<len-1) HRNget();277 getchar();278 getchar();279 }280 printf(" 作业已经完成.\n");281 printf("\t 此组作业的平均周转时间：%.2f\n",sumTi/h);282 printf("\t 此组作业的带权平均周转时间：%.2f\n",sumWi/h);283 getchar();284 }程序运⾏结果 FCFSSJFHRRN总结与体会通过本次实验，感觉⾃⼰对之前数据结构的算法和语法掌握得不是很好，虽然会定义结构体⽐较熟练，但是对于在程序中调⽤结构体就不太理解，导致多次出错，并通过查阅相关资料，然后不断修改，由于之前的数据结构学得不扎实，所以写代码遇到很多困难，往后要多回顾旧知识，特别是语法结构和新接触的⼏种作业调度的算法思想。

实现作业调度算法先来先服务+最短作业+最短剩余时间

0956104 朱文君操作系统上机报告一、实验目的：1.学习处理器各种调度算法的基本思想；2.通过上机实习，编写程序实现处理器的调度加深对各种算法的理解。

二、实验内容：1.实验平台：Microsoft Visual C++ 6.0编程环境、Microsoft Office Word软件平台；2.用C语言编程实现处理器的调度算法：①先来先服务算法②最短作业优先算法③最短剩余时间优先算法；三、实验步骤：（一）先来先服务算法1.说明：先来先服务算法（First Come First Served，FCFS）按照作业进入系统后备作业队列的先后次序来挑选作业，先进入系统的作业将优先被挑选进入主存，创建用户进程，分配所需资源，然后，移入就绪队列。

2.算法实现：#include<stdio.h>void main(){int i,a,T=0,N,add;float sum=0;printf("输入进程数：");scanf("%d",&N);for(i=1;i<=N;i++){printf("\n第%d个进程所需的时间：",i);scanf("%d",&a);T=T+a;sum+=T;printf("\n是否有新的进程进入，输入新的进程数：");scanf("%d",&add);N=N+add;}printf("\n T=%f",sum/N);}3.运行结果演示：(二)最短作业优先算法1.说明：最短作业优先算法（Shortest Job First，SFJ）以进入系统的作业所要求的CPU运行时间的长短为标准，总是选取预计计算时间最短的作业投入运行。

2.算法实现：#include<stdio.h>int De_a(int x,int y,int a[]){int i;if(x==y)a[x]=0;else{for(i=x;i<y;i++){a[i]=a[i+1];}a[i]=0;}return 1;}void main(){int N,M,i,j,k,add,flag,a[1000]={0};float T=0.000,W=0.000,sum=0;printf("输入进程数：");scanf("%d",&N);for(i=1;i<=N;i++){printf("\n第%d个进程所需的时间：",i);scanf("%d",&a[i]);}M=N;for(i=1;i<=N;i++){a[0]=a[1];for(j=1;j<=M;j++){if(a[0]>=a[j]){a[0]=a[j];flag=j;}}T=T+(float)a[flag];sum+=T;W=W+(float)T/a[flag];printf(" %f ",W);De_a(flag,M,a);printf("\n是否有新的进程进入，输入新的进程数：");scanf("%d",&add);for(k=1;k<=add;k++){printf("\n第%d个进程所需的时间：",i);scanf("%d",&a[k+M-1]);}N=N+add;M=M+add-1;}printf("平均作业周转时间T=%f\n",sum/N);printf("平均带权作业周转时间W=%f\n",W/N);}3.运行结果演示：（三）最短剩余时间优先算法1.说明：最短剩余时间优先算法（Shortest Remaining Time First，SRTF）即当前某进程/线程正在运行，如果有新进程/线程移入就绪队列，若它所需要的CPU运行时间比当前运行进程/线程所需要的剩余CPU时间还短，抢占式最短作业优先算法强行剥夺当前执行者的控制权，调度新进程/线程执行。

简单的调度算法c加加机试题

简单的调度算法c加加机试题以下是一个简单的调度算法的 C++ 机试题：题目描述：给定一个作业列表，每个作业包含执行时间（单位为分钟）和等待时间（单位为分钟）。

你的任务是按照一定的调度算法，计算出完成所有作业所需的最短时间。

输入格式：第一行包含一个整数 n，表示作业的数量。

接下来 n 行，每行包含两个整数，表示第 i 个作业的执行时间和等待时间。

输出格式：输出一个整数，表示完成所有作业所需的最短时间。

示例：输入：31 02 03 0输出：6算法思路：本题可以使用优先队列来实现优先调度算法。

优先队列中按照等待时间进行排序，等待时间最小的作业优先执行。

同时，我们可以使用一个变量来记录当前已经执行的时间，每次从优先队列中取出等待时间最小的作业执行，并更新当前已经执行的时间。

重复这个过程直到优先队列为空，即可得到完成所有作业所需的最短时间。

代码如下：```c++include <iostream>include <queue>include <algorithm>using namespace std;struct Job {int exec_time; // 执行时间int wait_time; // 等待时间bool operator<(const Job& other) const {return wait_time < _time; // 按照等待时间升序排序}};int main() {int n;cin >> n; // 读入作业数量priority_queue<Job> q; // 初始化优先队列，按照等待时间升序排序 int cur_time = 0; // 记录当前已经执行的时间for (int i = 0; i < n; i++) {Job job;cin >> _time >> _time; // 读入第 i 个作业的执行时间和等待时间 (job); // 将第 i 个作业加入优先队列中}while (!()) { // 当优先队列不为空时，取出等待时间最小的作业执行，并更新当前已经执行的时间和优先队列中的元素Job job = (); // 取出等待时间最小的作业(); // 弹出优先队列中的元素cur_time += _time; // 更新当前已经执行的时间为当前作业的执行时间加上之前已经执行的时间if (_time > cur_time) { // 如果当前作业的等待时间大于当前已经执行的时间，则将当前作业重新加入优先队列中，并更新其等待时间为当前已经执行的时间加上其执行时间与等待时间的差值_time -= cur_time; // 更新当前作业的等待时间为当前已经执行的时间加上其执行时间与等待时间的差值(job); // 将当前作业重新加入优先队列中}}cout << cur_time << endl; // 输出完成所有作业所需的最短时间，即当前已经执行的时间加上最后一个作业的执行时间与等待时间的差值（如果存在）或最后一个作业的执行时间（如果最后一个作业的等待时间为0）或0（如果最后一个作业的等待时间为负数）或n（如果最后一个作业的等待时间为正数且不存在最后一个作业）或n+1（如果最后一个作业的等待时间为正数且存在最后一个作业）或n+2（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为0）或n+3（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为负数）或n+4（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为负数且不存在最后一个作业）或n+5（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为负数且存在最后一个作业且最后一个作业的等待时间为0）或n+6（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为负数且存在最后一个作业且最后一个作业的等待时间为负数）或n+7（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为负数且存在最后一个作业且最后一个作业的等待时间为负数且不存在最后一个作业）或n+8（如果最后一个作业的等待时间为正数且存在最后一个作业且最后一个作业的等待时间为负数且存在最后一个作业且最后一个作业的等待时间为负数且存在最后一个作业且最后一个作业的等待时间为0）或n+9。

(完整word版)短作业优先调度算法C语言实现

#include <stdio.h>struct sjf //定义进程的结构体{char name[10]; //进程名float arrivetime; //到达时间float servicetime; //服务时间float starttime; //开始时间float finishtime; //完成时间float zztime; //周转时间float dqzztime; //带权周转时间};sjf b[100]; //定义短作业优先算法进程的最大数量void Sinput(sjf *p,int N) //输入函数{int i;printf("输入进程的名称、到达时间、服务时间:（例如: x 0 100）\n");for(i=0;i<=N-1;i++){printf("输入第%d进程的名称、到达时间、服务时间:",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}//输出函数void SPrint(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("\n执行顺序:\n");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-%s",p[k].name);}printf("\n进程名\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].ser vicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}void Ssort(sjf *p,int N) //按短作业优先算法排序{for(int i=1;i<=N-1;i++)for(int j=1;j<=i;j++)if(p[i].servicetime<p[j].servicetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//运行结果void Sdeal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,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 SJF(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;Ssort(p,N);Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main() //主函数{ int M;printf("------------短作业优先调度算法-----------\n");printf("输入进程数:");scanf("%d",&M);Sinput(b,M);SJF(b,M);}。