下载文档原格式
生活中有哪些静态优先级调度算法的例子总结：这里主要介绍了多任务操作系统系统中的任务调度及其算法，比较了Linux系统和UCOS系统中的linux上下文切换，具体实现可以参考Linux内核ucos ii源代码和UCOSucos ii源代码。
摘要：本文从实时操作系统的调度功能入手,简单介绍了实时磁盘调度算法的分类和种类,并主要讨论动静态优先级调度算法的特点和实现。
接下来本文介绍了两类动态优先级调度算法：截止时间优先调度算法和最短空闲时间优先调度算法的定义及实现方式。
然后将静态优先级调度算法调度与动态调度进行比较,突出动静态优先级调度算法的特点,同时指出其可能导致死锁有四种情况的优先级反转、死锁等不良后果。
然后具体介绍了优先级反转的定义以及解决该问题的两种方案：采用优先级继承在这些情况中，主要由于系统调用或中断而进入内核态，或者当前进程本来在内核态时，返回用户态时发生的。
在抢占式内核中，利用中断来实现上下文切换是一个非常理想的机制。
中断发生时，中断会强制CPU把控制权交给操作系统，也就相当于一次上下文切换。
这样不仅可以减少程序出错的后果，而且提高切换的效率。
UCOS就是利用中断机制进行上下文切换的典型例子。
在UCOS中，如果调度程序决定任务需要切换，就会调用上下文切换OS_TASK_SW()进行实际的上下文切换。
OS_TASK_SW()是宏调用，含有微处理器的软中断指令，利用此中断来实现任务之间的上下文切换。
所以OS_TASK_SW()是一个体系结构相关的宏，对于不同的硬件体系机构，有不同的实现方式，这也是UCOS在不同硬件体系结构中移植的一个要点。
在多任务系统中，进程(任务)的调度主要包括以下一些方面：在多任务系统中，都会提供一个系统函数来进行进程(任务)间切换，综合来说，他们有两种进程(任务)切换方式：在UCos中，通过调用OSSched()来完成。
在UCOS中，所有的任务有不同的优先级，不会出现同一优先级上有多个任务的情况，而且也没有系统调用的概念，所以任务调度的延迟调用只能出现在中断处理完成返回时，在OSIntExt()函数中，检查是否有高优先级的任务就绪，如果有高优先级的任务就绪，进行任务切换。
第四章一.选择题1.预防死锁不可以去掉以下__A__条件。
A．互斥 B.请求与保持 C.不可剥夺 D.环路2.资源分配图是否可以完全简化是判断死锁的_C__。
A．充分条件 B.必要条件 C.充分必要条件 D.什么也不是3.设有4个作业同时到达，每个作业的执行时间是2min，它们在一台处理机上按单道方式运行，则平均周转时间为_B__。
A．1min B.5min C.2.5min D.8min4.若系统中有8台绘图仪，有多个进程均需要使用两台，规定每个进程一次仅允许申请一台，则至多允许_C__各进程参与竞争，而不会发生死锁。
A.5 B .6 C .7 D .85.响应比高者优先作业调度算法除了考虑进程在CPU上的运行时间，还考虑以下__D_因素。
A.输入时间B.完成时间C.周转时间D.等待时间6.产生系统死锁的原因可能是_B__。
A.一个进程进入死循环B.多个进程竞争资源出现了循环等待C.进程释放资源D.多个进程竞争共享型设备7.以下_B__方法可以解除死锁。
A.挂起进程B.剥夺资源C.提高进程优先级D.降低进程优先级8.采用有序分配资源的策略可以破坏产生死锁的__D_。
A.互斥条件B.请求与保持条件C.不可剥夺条件D.环路条件9.连个进程争夺同一个资源_B__。
A.一定死锁B.不一定死锁C.不死锁D.以上说法都不对10.以下解决死锁的方法中，属于预防策略的是_C__。
A.化简资源分配图B.银行家算法C.资源的有序分配D.死锁检测法11.下面__D_说法是对可剥夺系统的正确描述。
A.时间片轮转法是一种可剥夺式调度B.进程因等待某一事件而引起系统调度是一种可剥夺式调度C.实时系统采用可剥夺式调度D.优先级低的进程放弃CPU，让优先级高的进程运行12.以下关于调度的说法__A__正确。
A.进程通过调度得到CPUB.优先级是进程调度的主要依据，一旦确定就不能改变C.在单CPU的系统中，任何时刻都有一个进程处于运行状态D.进程申请CPU得不到时，其状态为阻塞13.既考虑进程的等待时间，又考虑进程的执行时间的调度算法是__A__。
关于处理机调度算法《操作系统》教材中，介绍了常用的作业调度算法和进程调度算法。
其中先来先服务法（FCFS）和优先级法对作业调度和进程调度都适用，时间片轮转法（RR）适用于进程调度。
此外，还介绍了其他调度算法，如短作业优先法、最短剩余时间优先法、多级队列法和多级反馈队列法，这4个算法不是课程的重点内容，不作为考核要求。
需要指出的是：（1）在作业调度和进程调度中同时出现的算法，如FCFS、优先级法，其使用原理是基本相同的；（2）作业调度算法和进程调度算法应严格与存储管理中的“请求淘汰换页算法”相区别，注意不要混淆。
下面，结合具体的例题，详解调度算法：1. 先来先服务法（FCFS）算法描述：每次调度时，从后备作业队列或就绪队列中选择一个最先进入该队列的作业或进程。
【例1】下表给出作业l，2，3的到达时间和运行时间。
采用先来先服务调度算法，试问作业调度的次序和平均周转时间各为多少？（时间单位：小时，以十进制进行计算。
）分析解题关键是要根据系统采用的调度算法，弄清系统中各道作业随时间的推进情况。
我们可以用一个作业执行时间图来形象地表示作业的执行情况，帮助我们理解此题。
先来先服务调度算法是按照作业到达的先后次序挑选作业，先进入的作业优先被挑选。
即按照“排队买票”的办法，依次选择作业。
其作业执行时间图如下：或者简化为下图：作业1 作业2 作业3| | | | 时间0 8 12 13由于作业1，2，3是依次到来的，所以刚开始时系统中只有作业1，于是作业1被选中。
在8.0时刻，作业1运行完成，这时作业2和作业3已经到达，都在系统中等待调度，按照先来先服务法的规定，每次调度最先进入就绪队列中的作业，由于作业2比作业3先到达，于是作业2被优先选中运行。
待作业2运行完毕，最后运行作业3。
因此，作业调度的次序是1，2，3。
另外，要记住以下周转时间和平均周转时间的算术公式： 作业i 的周转时间T i ＝作业i 的完成时间－作业i 的提交时间系统中n 个作业的平均周转时间nT T ni i 1)(1⨯=∑=，其中Ti 为作业i 的周转时间。
实验一进程调度实验一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、例题：设计一个有 N个进程共行的进程调度程序进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
调度算法的流程图如下图所示。
三．实验题：1、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1。
或者，进程等待的时间超过某一时限时增加其优先数的值，等等。
2、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。
一．填空题1.现代操作系统的两个最基本的特征是（并发），（共享），（虚拟）和（异步）2.操作系统是计算机系统中的一个（管理者），它管理和控制计算机系统中的（各种硬件和软件资源）。
3.允许多个用户以交互方式使用计算机的操作系统称为（分时系统），允许多个用户将多个作业提交给计算机集中处理的操作系统称为（批处理系统），计算机系统能及时处理过程控制数据并做出响应的操作系统称为（实时系统）。
4.用户与操作系统之间的接口主要分为（命令接口）和（程序接口）两类。
5.进程控制块的初始化工作包括（标识信息），（处理器状态信息）和（处理器控制信息）。
在操作系统中引入线程概念的主要目的是（使得多个程序更好的并发执行同时又尽量减少系统的开销，有效的改善多处理机的性能）。
6.程序并发执行与顺序执行时相比产生了一些新特性，分别是：（间断性），（失去封闭性）和（不可再现性）。
7.进程是一个程序对某个数据集的（运行过程）。
8.如果系统有N个进程，则在等待队列中进程的个数最多可为（N-1）个。
9.在操作系统中，不可中断执行的操作称为（原语操作）。
10.如果信号量的当前值为-4，则表示系统中在该信号量上有（4 ）个等待进程。
11.在进程中，访问（临界资源）的代码称为临界区。
为保证进程（互斥）使用临界区，应在进程的临界区前设置（检查代码），在临界区后设置（退出代码）。
12.在单用户单任务环境下，用户独占全机，此时机内资源的状态，只能由运行程序的操作加以改变，此时的程序执行具有( 封闭性)性和( 可再现性)性。
（）（13.并发程序之间的相互制约，是由于它们( 相互合作)和( 共享资源)而产生的，因而导致程序在并发执行时，具有( 间断性)特征。
）14.在多用户环境下，由多个程序共享一台计算机，机内资源的状态将由多个程序来改变，因此使程序失去了在顺序执行时具有的( 封闭性)和( 可再现性)特性。
15.进程最基本的特征是( 动态性)，因为进程的实质是程序的一次执行过程，而且该特征还表现在进程由( 创建)而产生，由( 调度)而执行，由( 撤销)而消亡，即进程具有一定的生命期。
实验报告2012 ～2013 学年第一学期课程操作系统原理实验名称设计一个按优先数调度算法实现处理器调度的进程小组成员阮广杰、陈智磊、高天翔、董云鹏专业班级10级计本三班指导教师屠菁2012 年11 月29号操作系统实验报告实验目的：在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下处理器调度，设计一个按优先数调度算法实现处理器调度的进程，通过运行程序，能够清楚的表述优先数调度的过程，进一步掌握优先数调度算法的实现。
实验内容：设计一个按优先数调度算法实现处理器调度的进程。
实验步骤：概要设计：(1)假定系统有5个进程，每个进程用一个PCB来代表。
PCB的格式为：进程名、指针、要求运行时间、优先数、状态。
进程名——P1~P5。
指针——按优先数的大小把5个进程连成队列，用指针指出下一个进程PCB 的首地址。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——假设两种状态，就绪，用R表示，和结束，用E表示。
初始状态都为就绪状态。
(2) 每次运行之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 处理器总是选队首进程运行。
采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。
(4) 进程运行一次后，若要求运行时间不等于0，则将它加入队列，否则，将状态改为“结束”，退出队列。
(5) 若就绪队列为空，结束，否则，重复(3)。
详细设计：1、程序中使用的数据结构及符号说明：typedef struct PCB{char name[50];// 进程名以序号代替LPVOID lp;// 指向进程的长指针，模拟的，所以没用到。
int tm;// 需要运行的时间int prior;// 初始的优先数char state;// 状态struct PCB *next; // 指向下一个PCB块}PCB;3、源程序清单：//Main.cpp// prior.cpp : Defines the entry point for the application.//#include "stdafx.h"#include "resource.h"#include "MainDlg.h"#include <COMMCTRL.H>int APIENTRY WinMain(HINSTANCE hInstance,//当前进程句柄HINSTANCE hPrevInstance,// 前次进程句柄LPSTR lpCmdLine,// 启动信息int nCmdShow)//{//Enable IPAddress、Calendar.etcInitCommonControls();//系统调用函数DialogBox(hInstance, MAKEINTRESOURCE(IDD_MAIN), NULL, Main_Proc);return 0;}//MainDlg.cpp#include "stdafx.h"#include <windows.h>#include <windowsx.h>#include "resource.h"#include "MainDlg.h"#include "cross.h"#include "time.h"int MAX_NUM;// 用户输入进程数char *pst1="------------------------------------------------------------------------------\r\n"; char *pst2="=======================================\r\n";typedef struct PCB{char name[50];// 进程名以序号代替LPVOID lp;// 指向进程的长指针，模拟的，所以没用到。
第6章 进程调度练习题一、 单项选择题1、在分时操作系统中,进程调度经常采用(C )算法。
A 先来先服务 B 最高优先权 C 时间片轮转 D 随机2、 （B ）优先权是在创建进程时确定的，确定之后在整个进程运行期间不再改变A 先来先服务B 静态C 动态D 短作业3、 以优先级为基础的进程调度算法可以保证在任何时候正在运行的进程总是非等待状态下诸进程中优先级最高的进程。
上述描述是（ B ）A 正确的B 错误的二、填空题1、 进程调度方式通常有（非抢占式）和（抢占式）。
2、 所谓进程调度就是从处于（就绪）状态的一些进程中按某种算法选择一个进程，使其占有CPU ，使其该进程处于（执行）状态。
3、 进程调度算法采用时间片轮转法，时间片过大，就会使轮转法转化为（FCFS ）调度算法。
4、 进程调度负责（处理机）的分配工作。
5、 一种最常用的进程调度算法是把处理机分配给具有最高优先权的进程，而确定优先权的方法概括起来不外乎是基于（静态）特性和（动态）特性两种方法。
前者所得到的是（静态）优先权，后者所得到的是（动态）优先权。
6、 在（先来先服务）调度算法中，按照进程进入就绪队列的先后次序来分配处理机。
三、概念的区别与联系1、 作业调度与进程调度（1998西北大学考研试题）2、 静态优先数与动态优先数。
（1998西北大学考研试题） 四、解析题1、 假设有一台计算机，它有1M 内存，操作系统占有用200K ，每个用户进程也占用200K ，用户进程等待I/O 的时间为80%，若增加1M 内存，则CPU 的利用率将提高多少？解：1M 内存的情况：1）支持用户进程数：（1024K-200K ）/200K=4.12 所以4个用户进程。
2）CPU 利用率： 先求CPU 空闲（4个用户均处于等待I/O 状态）概率P=（80%）4，然后再求CPU 利用率1-P1-P =1-（80%）4 = 1-0.84=59%增加1M 内存的情况：1）支持用户进程数：（2*1024K-200K ）/200K=9.24 所以9个用户进程。
1. 调度类型高级调度——作业调度批处理系统中使用，周期较长。
低级调度——进程调度是最基本的一种调度，在三种类型的OS中都必须配置。
进程调度可采用非抢占或抢占两种方式。
其中抢占方式允许调度程序根据某种原则，例时间片原则、优先权原则、短进程优先原则等去停止某个正在执行的进程，将已分配给该进程的处理机，重新分配给另一进程。
进程调度的运行频率最高，故算法不能太复杂。
中级调度——引入中级调度的目的是为了提高内存的利用率和系统吞吐量。
中级调度实际上是存储器管理中的对换功能。
2. 调度队列模型3. 选择调度方式和算法的准则周转时间（批处理）面向用户响应时间（分时）的准则截止时间的保证（实时）优先权准则面向系统系统吞吐量高（批处理）的准则处理机利用率好各类资源的平衡利用周转时间——指作业提交系统开始，到作业完成为止的时间间隔。
带权周转时间——作业的周转时间与系统为它提供的实际服务时间之比。
W=T/TS响应时间——从用户通过键盘提交一个请求开始，直至系统首次产生响应为止的时间。
截止时间——某任务必须开始执行的最迟时间，或必须完成的最迟时间。
吞吐量——单位时间内所完成的作业数。
4. 调度算法（作业调度、进程调度）先来先服务调度算法（FCFS）按进入后备（或就绪）队列的先后选择目标作业（或进程）。
有利于长作业（进程），不利于短作业（进程）。
最短作业优先调度算法SJ（P）F从后备（或就绪）队列中选择估计运行时间最短的作业（或进程）tn+1=a tn+(1-a) tn tn为实际值，tn为预测值SJF有效地降低作业的平均等待时间，提高了系统的吞吐量。
对长作业（或进程）不利，可能死等，且未考虑作业的紧迫程度。
时间片轮转调度算法（进程调度）系统将所有的就绪进程按先来先服务原则，排成一个队列，每次调度时把CPU分配给队首进程，令其执行一个时间片。
就绪队列中所有进程，在一个给定的时间内，均能获得一个时间片的处理机执行时间。
T=nq优先权调度算法适用于作业调度和进程调度。
进程调度算法代码1. 介绍在操作系统中，进程调度是操作系统的一个重要功能，用于控制不同进程的执行顺序和资源分配。
进程调度算法是决定进程调度顺序的方法和规则。
本文将介绍进程调度算法的基本概念和常见的调度算法，以及对应的代码实现。
2. 进程调度算法的分类常见的进程调度算法可以根据不同的标准进行分类，下面是几种常见的分类方式：2.1. 非抢占调度和抢占调度根据进程在运行时是否可以被抢占，进程调度算法可以分为非抢占调度和抢占调度。
非抢占调度是指一个进程在运行时不会被其他进程抢占，直到其自愿地放弃CPU资源。
常见的非抢占调度算法有先来先服务（FCFS）和短作业优先（SJF）。
抢占调度是指一个进程在运行时可以被其他进程抢占，例如高优先级进程可以抢占低优先级进程的CPU资源。
常见的抢占调度算法有优先级调度和时间片轮转调度。
2.2. 静态优先级调度和动态优先级调度根据进程的优先级是否固定，进程调度算法可以分为静态优先级调度和动态优先级调度。
静态优先级调度是指进程的优先级在创建时就确定，并且不会发生改变。
常见的静态优先级调度算法有先来先服务（FCFS）和短作业优先（SJF）。
动态优先级调度是指进程的优先级会根据运行情况进行动态调整。
常见的动态优先级调度算法有优先级调度和反馈调度。
3. 常见的进程调度算法3.1. 先来先服务（FCFS）先来先服务（First-Come, First-Served）是一个简单的非抢占调度算法，按照进程到达的先后顺序进行调度。
当一个进程开始执行时，直到它完成或者等待某个事件发生时，才会释放CPU资源。
以下是先来先服务调度算法的代码实现：void FCFS(Process[] processes) {int n = processes.length;int[] waitingTime = new int[n];int[] turnaroundTime = new int[n];waitingTime[0] = 0; // 第一个进程的等待时间为0// 计算每个进程的等待时间和周转时间for (int i = 1; i < n; i++) {waitingTime[i] = waitingTime[i-1] + processes[i-1].burstTime;turnaroundTime[i] = waitingTime[i] + processes[i].burstTime;}// 输出每个进程的等待时间和周转时间for (int i = 0; i < n; i++) {System.out.println("Process " + processes[i].pid + ":");System.out.println("Waiting Time: " + waitingTime[i]);System.out.println("Turnaround Time: " + turnaroundTime[i]);System.out.println();}}3.2. 短作业优先（SJF）短作业优先（Shortest Job First）是一个非抢占调度算法，优先选择执行时间最短的进程。
第三章1．在分时操作系统中，进程调度经常采用__________算法。
A 先来先服务B 最高优先权C 时间片轮转D 随机2．____静态___优先权是在创建进程时确定的，确定之后在整个进程运行期间不再改变。
A 先来先服务B 静态C 动态D 短作业3．在__先来先服务___调度算法中，按照进程进入就绪队列的先后次序来分配处理机。
4.进程调度算法采用等时间片轮转法时，时间片过大，就会使轮转法转化为____先来先服务__调度算法。
5.进程调度是最基本的一种调度,在3种类型的OS中都必须配置这级调度.进程调度可采用下述两种方式_________A 联机方式和批处理方式B 索引方式和顺序方式C 程序方式和抢占方式D 抢占方式和非抢占方式6._________调度算法有利于CPU繁忙型的作业,而不利于I/0繁忙型的作业.A 时间片轮转B 先来先服务C 短作业进程优先D 优先权7.下面有关选择进程调度算法的准则中不正确的是_________A 尽快响应交互式用户的需求B 尽量提高处理机利用率C 尽可能提高系统吞吐量D 适当增长进程就绪队列中的等待时间8.在计算机系统中,只有一个处理器,则多个进程将争夺CPU资源,如何把CPU有效地分配给进程,这是__进程调度___要解决的问题.9.若进程P一旦被唤醒就能投入运行，系统可能为______A分时系统，进程P的优先级最高B抢占调度方式，就绪队列上的所有进程的优先级皆比P的低C就绪队列为空队列，CPU中无运行进程D抢占调度方式，P的优先级高于当前运行的进程.10.下列进程调度算法中，____________可能会出现进程长期得不到调度的情况。
A 非抢占式静态优先权法B 抢占式调度中采用静态优先权法C 分时处理中的时间片轮转调度算法D 非抢占式调度中采用FIFO算法11．在抢占调度方式中，抢占的原则是_优先权原则__、_短作业优先原则__、_时间片原则___.12．产生死锁的必要条件是_互斥条件__、_请求和保持条件_、__不剥夺条件_、_环路等待条件__.13．银行家算法在解决死锁问题中是用于_______死锁的。
第一章操作系统简介一、单项选择题1.linux操作系统是（）A.单用户单任务操作系统B. 单用户多任务操作系统C. 多用户单任务操作系统D. 分时操作系统2.操作系统内核中文件系统模块的主要功能是（）A.实现虚拟存储B. 保存系统文档和用户文档C. 保护系统数据D. 实现对文件的按名存取和文件的存储3.下列关于批处理系统的叙述中，正确的是（）A.批处理系统允许多个用户与计算机直接交互B.批处理系统分为单道批处理系统和多道批处理系统。
C.单道批处理系统也可能同时是分时系统。
D.多道程序系统就是指多道批处理系统。
二、填空题1.单道批处理系统的内存中只能驻留_______ 道用户作业，CPU和内存资源被用户作业独占。
2.单道批处理系统与无操作系统的计算机系统相比而言，减少了______________ 的时间。
3.操作系统是一组控制和经管计算机_______ 和_______ 资源、合理地对各类作业进行调度，以及方便用户的程序集合。
4.并发是指两个或两个以上的事件在______________ 的发生。
5.现代操作系统的特征包括并发、_______、虚拟和异步。
三、简答题1.请说明操作系统的作用和功能。
作用：操作系统是控制和经管计算机系统内各种硬件和软件资源、合理有效地组织计算机系统的工作，为用户提供一个使用方便可扩展的工作环境，从而起到连接计算机和用户的接口作用功能：处理器经管、作业经管、存储器经管、设备经管、文件经管。
2.请说明单道批处理系统、多道批处理系统、分时系统的特点及优缺点。
1）单道批处理系统：最早出现的一种OS，具有单道性、自动性和顺序性。
与无操作系统的计算机系统相比而言，减少了人工操作的时间。
但由于作业独占CPU和内存，当作业进行I/O时，CPU只能等待I/O完成而无事可做，导致CPU资源不能得到充分利用。
2）多道批处理系统：支持多道程序驻留内存，CPU不再空闲等待I/O，具有多道性、无序性、调度性和复杂性。
操作系统第三章—.单选题1在三种基本类型的操作系统中,都设置（进程调度），在批处理系统中还应设置（）oA、⑴剥夺进度B、（2）作业调度C、（3）进程调度D、（4）中级调度E、（5）多处理机调度正确答案：B2在三种基本类型的操作系统中,都设置（进程调度），在批处理系统中还应设置（作业调度）;在分时系统中除了（进程调度）以外，通常还设置了（）oA、⑴剥夺进度B、（2）作业调度C、（3）进程调度D、（4）中级调度E、（5）多处理机调度正确答案：D3在三种基本类型的操作系统中,都设置（进程调度），在批处理系统中还应设置（作业调度）;在分时系统中除了（进程调度）以外:通常还设置了（中级调度），在多处理机系统中还需设置（）oA、（1）剥夺进度B、（2）作业调度C、（3）进程调度D、（4）中级调度E、(5)多处理机调度正确答案：E4在面向用户的调度准则中,()是选择实时调度算法的重要准则。
A、⑴响应时间快B、(2)平均周转时间短C、(3)截止时间的保证D、(4)优先权高的作业能获得优先服务E、⑸服务费低正确答案：C5在面向用户的调度准则中,()是选择分时系统中进程调度算法的重要准则。
A、⑴响应时间快B、(2)平均周转时间短C、(3)截止时间的保证D、(4)优先权高的作业能获得优先服务E、(5)服务费低正确答案：A6在面向用户的调度准则中()是批处理系统中选择作业调度算法的重要准则。
A、⑴响应时间快B、(2)平均周转时间短C、(3)截止时间的保证D、(4)优先权高的作业能获得优先服务E、⑸服务费低正确答案：B7在面向用户的调度准则中，()准则则是为了照顾紧急作业用户的要求而设置的。
A、⑴响应时间快B、(2)平均周转时间短C、(3)截止时间的保证D、(4)优先权高的作业能获得优先服务E、⑸服务费低正确答案：D8作业调度是从处于()状态的队列中选取投入运行。
A、⑴运行B、⑵后备C、⑶提交D、⑷完成E、⑸阻塞F、(6)就绪正确答案：B9()是指作业进入系统到作业完成所经过的时间间隔。
采用静态优先权优先算法的进程调度程序欧阳歌谷（2021.02.01）学号：姓名：专业：指导教师：日期：目录第1部分课设简介31.1 课程设计题目31.2 课程设计目的31.3 课程设计内容31.4 时间安排3第2部分实验原理分析32.1问题描述32.2解决方法4第3部分主要的功能模块53.1主要的函数53.2 测试用例及运行结果7第5部分总结及参考文献165.1 总结165.2 参考文献17第1部分课设简介1.1 课程设计题目采用静态优先权优先算法的进程调度程序1.2 课程设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
1）进一步巩固和复习操作系统的基础知识。
2）培养学生结构化程序、模块化程序设计的方法和能力。
3）提高学生调试程序的技巧和软件设计的能力。
4）提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
1.3 课程设计内容设计并实现一个采用静态优先权算法的进程调度演示程序1.4 时间安排1）分析设计贮备阶段（1 天）2）编程调试阶段（7 天）3）写课程设计报告、考核（2 天）第2部分实验原理分析2.1问题描述（1）每一个进程有一个PCB，其内容可以根据具体情况设定。
（2）进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定（3）可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、作业大小、进程优先级的初始化（4）可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间的同步关系，故只有两种状态）（5）采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列（6）有性能比较功能，可比较同一组数据在不同调度算法下的平均周转时间（7）具有一定的数据容错性2.2程序设计流程图2.3解决方法通过数组容纳所有数据，根据冒泡排序把数据按从小到大顺序排列，在分析a[0]和其他数据的大小，如果a[0]的完成时间大于其他数据就按照冒泡的排列顺序，如果小，就比较其他数据的优先级，按优先级大小排序。
采用静态优先权优先算法的进程调度程序学号：姓名：专业：指导教师：日期：目录第1部分课设简介 (3)1.1 课程设计题目 (3)1.2 课程设计目的 (3)1.3 课程设计内容 (3)1.4 时间安排 (3)第2部分实验原理分析 (3)2.1问题描述 (3)2.2解决方法 (4)第3部分主要的功能模块 (5)3.1主要的函数 (5)3.2 测试用例及运行结果 (7)第4部分源代码 (9)第5部分总结及参考文献 (16)5.1 总结 (16)5.2 参考文献 (17)第1部分课设简介1.1 课程设计题目采用静态优先权优先算法的进程调度程序1.2 课程设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
1）进一步巩固和复习操作系统的基础知识。
2）培养学生结构化程序、模块化程序设计的方法和能力。
3）提高学生调试程序的技巧和软件设计的能力。
4）提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
1.3 课程设计内容设计并实现一个采用静态优先权算法的进程调度演示程序1.4 时间安排1）分析设计贮备阶段（1 天）2）编程调试阶段（7 天）3）写课程设计报告、考核（2 天）第2部分实验原理分析2.1问题描述（1）每一个进程有一个PCB，其内容可以根据具体情况设定。
（2）进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定（3）可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、作业大小、进程优先级的初始化（4）可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间的同步关系，故只有两种状态）（5）采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列（6）有性能比较功能，可比较同一组数据在不同调度算法下的平均周转时间（7）具有一定的数据容错性2.2程序设计流程图2.3解决方法通过数组容纳所有数据，根据冒泡排序把数据按从小到大顺序排列，在分析a[0]和其他数据的大小，如果a[0]的完成时间大于其他数据就按照冒泡的排列顺序，如果小，就比较其他数据的优先级，按优先级大小排序。
第3部分主要的功能模块3.1主要的函数void fcfs(){int i,j,n,min,px;float sum1,sum2;printf("\t请输入有n个进程(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n\n");struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}3.2 测试用例及运行结果第4部分源代码#include"stdio.h"#define N 50void main(){ void fcfs();void yxj();int a;while(true){printf("\n\n");printf("\t\t/*************************/");printf("\n\t\t/* 1、先到先服务调度*/");printf("\n\t\t/* 2、优先级优先调度*/");printf("\n\t\t/* 0、退出*/\n");printf("\t\t/*************************/");printf("\n\n\t请选择菜单项：\t");scanf("%d",&a);printf("\n");switch(a){case 1: fcfs();break;case 2: yxj();break;default: break;}if(a<0&&a>2) break;}}void fcfs(){int i,j,n,min,px;float sum1,sum2;printf("\t请输入有n个进程(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n\n");struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\t1、按id号依次输出\n");printf("\t2、按完成顺序依次输出\n");printf("\n\t请选择输出顺序:\t");scanf("%d",&px);printf("\nid：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n"); sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}void yxj(){int i,j,n,min,px;int b=0,z;float sum1,sum2;printf("\n\t\t请输入有n个进程(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n\t请选择输出顺序\n");printf("\t1、按id号依次输出\n");printf("\t2、按完成顺序依次输出\n");scanf("%d",&px);printf("\nid：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[ i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[ i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}第5部分总结及参考文献5.1 总结1）多线程编程对于解决一些并发性的问题是很高效的，而且也很必要，现在学会了使用多线程编程，对于以后解决类似的并发性问题（例如网络编程中经常遇到的多客户线程同时访问的问题），都会很有用。
