进程调度
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。
进程调度
Linux调度程序提高交互式程序的优先级，让它们运行更频繁。因此， 调度程序提供较长的默认时间片给交互式程序。此外，调度程序还能根 据进程的优先级动态调整分配给它的时间片，从而保证了优先级高的进 程，执行的频率高，执行时间长。通过动态掉正优先级和时间片的长度 机制，Linux调度性能不但非常稳定而且也很强健。
计算优先级和时间片
进程拥有一个初始的nice值(优先级)，范围是-20~19，默认 是0，进程task_struct的static_prio域存放这个值，因为它 从一开始由用户指定，不能修改，所以是静态优先级。 调度程序用到的动态优先级存放在prio域里，动态优先级 是通过一个关于静态和进程交互性的函数关系计算而来。 effective_prio()函数返回一个进程的动态优先级。 调度程序通过一些推断来获取准确反映进程时I/O消耗型还 是处理器消耗型。 为了支持这种推断，Linux记录了一个进程用于休眠和用于 执行的时间。该值存放在task_struct的sleep_avg域中，范 围是从0到MAX_SLEEP_AVG。默认值是10毫秒， sleep_avg会根据它的休眠时间的长短而增长，直到最大值 为止，进程没运行一个节拍，sleep_avg就相应减少，直到 0为止。
可运行队列
调度程序中最基本的数据结构是运行队列。 可执行队列定义于kernel/sched.c中，由结构runqueue 表示，可执行队列是给定处理器上可执行进程的链表 ，每个处理器一个。每一个可投入运行的进程都惟一 的归属于一个可执行队列。此外，可执行队列中还包 含每个处理器的调度信息。因此，可执行队列是每一 个处理器最重要的数据结构。
重新计算时间片
操作系统在所有的进程的时间片都用完时，会重新计 算每个进程的时间片。 典型的实现是循环访问每个进程： for(系统中的每个人物){ 重新计算优先级 重新计算时间片 }
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
进程调度的实验总结
进程调度的实验总结咱就说进程调度这个事儿啊，你可别小看它，这就好比是一场精彩的大戏！在计算机的世界里，各个进程就像是舞台上的演员，都眼巴巴地等着上台表演呢！进程调度啊，就是那个决定谁先上台，谁后上台的导演。
它得公平公正地安排好每个进程的出场顺序，不能让某个进程一直霸占着舞台，也不能让其他进程等得花儿都谢了。
这要是安排不好，那可就乱套啦！你想想看，要是有个进程特别重要，比如说像正在播放的视频，那肯定得让它优先表演呀，不然画面卡顿了，咱不得着急上火嘛！可要是有个不那么重要的进程，比如后台自动更新啥的，那就可以让它先等等，别抢了重要进程的风头。
这就跟咱生活中排队一样，着急的人先办事儿，不着急的就往后靠靠。
但进程调度可比咱排队复杂多了，它得考虑好多因素呢！比如进程的优先级、等待时间、占用资源等等。
这就像是导演要考虑演员的演技、知名度、档期一样，可不能马虎。
有时候啊，进程调度就像是在走钢丝，得小心翼翼地保持平衡。
要是过于偏向某个进程，其他进程可不干啦，会闹脾气的哟！电脑可能就会变得慢吞吞的，或者干脆罢工给你看。
咱再打个比方，进程调度就像是交通警察，指挥着车辆有序通行。
要是警察乱指挥，那路上还不得堵成一锅粥啊！同样的道理，进程调度要是乱来，那计算机系统也得乱套。
而且啊，不同的操作系统有不同的进程调度算法呢，就像是不同的导演有不同的风格。
有的算法注重公平性，让每个进程都有机会上台；有的算法则更注重效率，让重要的进程赶紧表演完。
咱在使用电脑的时候，可能感觉不到进程调度在背后默默地工作，但它真的很重要啊！它就像是一个默默付出的幕后英雄，保障着我们的电脑能够顺畅运行。
所以啊，可别小瞧了这进程调度，它虽然看不见摸不着，但却起着至关重要的作用呢！它让我们的计算机世界变得有序、高效，就像一场精彩绝伦的演出，离不开导演的精心安排一样。
咱得感谢进程调度这个小能手，让我们能愉快地使用电脑呀！这就是我对进程调度的实验总结啦，是不是挺有意思的呀！。
进程调度
引起进程调度的主要因素有：（1）一个进程运行完毕。
（2）一个正在运行的进程被阻塞。
（3）在抢占式调度中，一个高优先级的进程被创建。
（4）在抢占式调度中，一个高优先级进程由阻塞唤醒。
（5）在轮转式调度中，正垢进程运行完进程调度的概念无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。
另外，系统进程也同样需要使用处理机。
这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
进程有四个基本属性1.多态性从诞生、运行，直至消灭。
2.多个不同的进程可以包括相同的程序3.三种基本状态它们之间可进行转换4.并发性并发执行的进程轮流占用处理器进程的三种基本状态:1.等待态：等待某个事件的完成；2.就绪态：等待系统分配处理器以便运行；3.运行态：占有处理器正在运行。
运行态→等待态往往是由于等待外设，等待主存等资源分配或等待人工干预而引起的。
等待态→就绪态则是等待的条件已满足，只需分配到处理器后就能运行。
运行态→就绪态不是由于自身原因，而是由外界原因使运行状态的进程让出处理器，这时候就变成就绪态。
例如时间片用完，或有更高优先级的进程来抢占处理器等。
就绪态→运行态系统按某种策略选中就绪队列中的一个进程占用处理器，此时就变成了运行态进程调度的分级高级、中级和低级调度作业从提交开始直到完成，往往要经历下述三级调度：高级调度：(High-Level Scheduling)又称为作业调度，它决定把后备作业调入内存运行；低级调度：(Low-Level Scheduling)又称为进程调度，它决定把就绪队列的某进程获得CPU；中级调度：(Intermediate-Level Scheduling)又称为在虚拟存储器中引入，在内、外存对换区进行进程对换。
进程调度的方式进程调度有以下两种基本方式：非剥夺方式分派程序一旦把处理机分配给某进程后便让它一直运行下去，直到进程完成或发生某事件而阻塞时，才把处理机分配给另一个进程。
操作系统五种进程调度算法的代码
操作系统五种进程调度算法的代码一、先来先服务（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;输出：。
操作系统实验——动态优先级进程调度实验报告
1.实验名称：动态优先权调度过程中就绪队列的模拟2.实验要求：采用动态优先权的进程调度算法，用C语言编程模拟调度过程中每个时间片内的就绪队列。
3.实验内容：（1）每个进程控制块PCB用结构描述，包括以下字段：*进程标识符id*进程优先数priority,并规定优先数越大的进程，其优先权越高。
*进程已占用的CPU时间cputime*进程还需占用的CPU时间alltime，当进程运行完毕时，aiitime变为0*进程的阻塞时间startblock,当进程再运行startblock个时间片后，进程将进入阻塞状态*进程被阻塞的时间blocktime,已阻塞的进程再等待blocktime个时间片后，将转换成就绪状态*进程状态state*队列指针next,将PCB排成队列。
2）调度前，系统中有五个进程，它们的初始状态如下：3）进程在就绪队列呆一个时间片,优先数增加1。
4）进程每运行一个时间片，优先数减3。
5）按下面格式显示每个时间片内就绪队列的情况：READY_QUEUE:->id1->id24.任务分析进程控制块用结构体来表示，包含它的各项属性。
建立两个队列：一个就绪队列，一个阻塞队列。
创建一个进程控制块表示当前正在运行的进程。
程序开始运行时，所有进程都在就绪队列中。
当startblock减少到0时，进程进入阻塞队列。
在阻塞队列中的进程，当blocktime减少到0时，转入就绪队列。
在就绪队列中的进程，如果优先级比当前正在执行的进程高，就可以取代当前进程获取时间片。
当前进程如果运行完毕，就绪队列中优先级最高的进程就可以成为新当前进程。
5.程序流程图#include〈iostream〉#include〈string〉usingnamespace std;#define LEN5typedefenum STATE{READYBLOCKEND}STATE;//定义进程控制块typedefstruct PCB{int id;int priority;int cputime;int alltime;int startblock;int blocktime;STATE state;}PCB;//定义队列typedefstruct queue{int si ze;PCB*data[LEN];}Queue;PCB ps[LEN];PCB*cp; //进程最大数量//进程状态//就绪//阻塞//完成//进程标识符//进程优先级//已占用的CPU时间//还需占用的CPu时间//阻塞时间//被阻塞时间//进程状态//队列中进程的数量//进程的指针//进程数组//当前正在运行的进程6.程序清单Queue rQueue,bQueue;//就绪队列和阻塞队列//就绪队列按优先级降序排序(使用了冒泡排序法)void rQueueSort(){ PCB*temp;for(int i=0;i<rQueue.size-1;i++){for(int j=0;j<rQueue.size-1-i;j++){if(rQueue.data[j]-〉priority<rQueue.data[j+1]-〉priority){temp=rQueue.data[j];rQueue.data[j]=rQueue.data[j+1];}}rQueue.dataj+1]=temp;}}//初始化void init(){//给进程赋值for(int i=0;i<LEN;i++){ps[i].id=i;ps[i].state=READY;ps[i].cputime=0;ps[i].alltime=3;ps[i].blocktime=0;ps[i].startblock=T;}ps[0].priority=9;ps[1].priority=38;ps[2].priority=30;ps[3].priority=29;ps[4].priority=0;ps[2].alltime=6;ps[4].alltime=4;ps[0].startblock=2;ps[0].blocktime=3;cp=NULL;//当前进程赋空bQueue.size=0;//阻塞队列没有进程for(int i=0;i<LEN;i++){bQueue.data[i]=NULL;rQueue.data[i]=&ps[i];}rQueue.size=5;//所有进程全部进入就绪队列rQueueSort();//对就绪队列排序}//打印void print(){cout〈〈"\nRUNNINGPROG:";if(cp!=NULL){cout〈〈cp->id;}cout<<"\nREADY_QUEUE:";for(int i=0;i<rQueue.size;i++){cout〈〈"-〉"〈〈rQueue.data[i]-〉id; }cout<<"\nBLOCK_QUEUE:";for(int i=0;i<bQueue.size;i++){cout〈〈"-〉"〈〈bQueue.data[i]-〉id; }cout〈〈"\n"<<endl;cout<<"ID\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].id<<"\t";}cout<<"\nPRI0RITY\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].priority〈〈"\t";}cout<<"\nCPUTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].cputime〈〈"\t";}cout<<"\nALLTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].alltime〈〈"\t";}cout<<"\nSTARTBLOCK\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].startblock<<"\t";}cout<<"\nBLOCKTIME\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].blocktime<<"\t";}cout<<"\nSTATE\t\t";for(int i=0;i<LEN;i++){if(ps[i].state==READY){cout<<"READY"<<"\t";}elseif(ps[i].state==BLOCK){cout<<"BLOCK"<<"\t";}elseif(ps[i].state==END){cout〈〈"END"<<"\t";}}cout〈〈endl;}//出队，返回进程指针PCB*pop(Queue*q){PCB*temp;if(q-〉size>0){temp=q-〉data[0];//取出队首进程for(int i=0;i<q-〉size-1;i++){q-〉data[i]=q-〉data[i+1];//其他进程依次向前移动}q->size__;return temp;//返回队首进程}return NULL;}//入队void push(Queue*q,PCB*p){if(q_>size<LEN){q_>data[q_〉size]=p;//将入队的进程放在队尾q_>size++;}return;}//运行进程void run(){if(rQueue.size〉0||bQueue.size〉0){if(cp==NULL){//程序一开始运行时，从就绪队列取出首进程cp=pop(&rQueue);}//当前进程没有结束，但优先级比就绪队列首进程低if(cp_〉alltime〉0&&cp_>priority<rQueue.data[0]_〉priority){}push(&r Queue,c//改变进程状态//从就绪队列取出新的当前进程//修改当前进程的状态 //将当前进程加入阻塞队列 //从就绪队列取出新的当前进程{//当前进程的startblock 为正数时//运行一次减一个时间片//减到0时，修改进程状态//每运行一个时间片//就绪队列中的进程优先级+1//每运行一个时间片//阻塞队列中的进程blocktime-1//将当前进程放入就绪队列 //就绪队列队首进程成为当前进程if (cp-〉alltime==0){cp->state =END ;cp=pop(&rQueue); }//如果当前进程运行结束//startblock 为0,标志着当前进程要进入阻塞状态if (cp —>startblock==0&&cp —>blocktime>0){cp —>state=BLOCK ; push(&bQueue,cp); cp=pop(&rQueue); }elseif (cp —>startblock>0)cp —>st artblock 一; }cp —>alltime ——;if (cp —>alltime==0){cp —>state=END ;for (int i=0;i<rQueue.size;i++){rQueue.data[i]-〉priority++; }for (int i=0;i<bQueue.size;i++){if (bQueue.data[i]-〉blocktime>0){bQueue.data[i]-〉blocktime--; }//当阻塞队列队首进程blocktime 为0时if (bQueue.size 〉0&&bQueue.data[0]-〉blocktime==0){bQueue.data[0]-〉state=READY ;//修改进程状态push(&rQueue,pop(&bQueue));//将阻塞队列首进程取出，放入就绪队列cp —〉priority-=3;//修改当前进程的优先级cp —>cputime++; //当前进程占用CPU 时间片+1 if (cp —>alltime>0){//当前进程还需运行的时间片-1}//每运行一个时间片，就绪队列排一次序rQueueSort();} }//主函数int main(){init();//初始化 print();//打印进程信息 while (1){_sleep(1000);if (rQueue.size==0&&bQueue.size==0){//当两个队列都为空时，结束程序cp-〉state=END ;break ; }run();//运行进程 print();//打印进程信息 }return 0; }7.实验过程记录m 匚:\WINDQWS\system32\cmd.exe程序开始执行，当前进程是优先级最高的1号进程，1号进程的优先级减3、cputime++、执行几次之后，1号进程执行完毕而且优先级也不是最高的了，所以优先级为33的2号进程成为当前进程，开始执行。
操作系统的调度名词解释
操作系统的调度名词解释作为计算机科学中的重要概念，操作系统的调度在计算机系统的运行中起到了至关重要的作用。
通过合理的调度算法，操作系统能够合理分配和管理计算机资源，提高系统的性能和效率。
本文将对操作系统调度中的一些重要名词进行解释，以帮助读者更好地理解和掌握这一领域。
1. 进程调度进程调度是操作系统中的一个重要概念，它指的是操作系统通过预设的调度算法，合理选择优先级最高的进程，并分配CPU时间片给该进程执行。
进程调度的目标是提高系统的性能和响应速度，以确保各个进程都能得到公平的执行机会。
常见的进程调度算法包括先来先服务、短作业优先、时间片轮转等。
2. 线程调度线程调度是对操作系统中线程的分配和执行进行管理和调度的过程。
线程调度的目标是合理分配CPU时间片，使得多个线程能够并发执行，以提高程序的效率和响应速度。
常见的线程调度算法有优先级调度、时间片轮转、多级反馈队列等。
3. 中断调度中断调度是操作系统对中断事件的处理和分配过程。
在计算机运行中，发生中断事件时，操作系统需要及时响应并进行相应的处理操作。
中断调度的目标是尽快响应中断事件，将控制权转移到相应的中断处理程序，并在处理完之后返回原来的进程继续执行。
4. IO调度IO调度是操作系统在处理IO请求时的调度过程。
由于独立于CPU的IO设备存在速度差异，操作系统需要合理调度IO请求的顺序和时间，以提高系统的整体性能和效率。
常用的IO调度算法有先来先服务、最短寻道时间优先、电梯算法等。
5. 内存调度内存调度是指操作系统对内存中进程的分配和管理过程。
在多道程序设计环境下，操作系统需要合理选择和分配内存资源，以提高系统的利用率和性能。
内存调度的目标是实现内存的最佳利用和动态分配。
常见的内存调度算法有分页调度、分段调度、段页式调度等。
6. 磁盘调度磁盘调度是指操作系统中对磁盘访问请求的调度过程。
由于磁盘访问需要相当的时间，操作系统需要选择合适的算法来优化磁盘访问顺序，以提高磁盘的读写效率和响应时间。
进程调度知识点总结图
进程调度知识点总结图1. 进程调度概述进程调度是操作系统中的一个重要组成部分，它负责决定哪些进程能够在CPU上执行，以及它们的执行顺序。
进程调度的主要目标是提高系统的吞吐率、减少响应时间、以及实现公平的资源分配。
2. 进程状态在进行进程调度之前，我们需要了解进程的状态。
常见的进程状态包括就绪态、运行态、阻塞态等。
就绪态的进程可以在任何时刻被调度到CPU上执行；运行态的进程正在CPU 上执行指令；阻塞态的进程由于等待外部事件而暂时无法执行。
3. 调度器调度器是负责进行进程调度的组件。
它可以根据特定的调度算法来决定哪些进程应该被分配CPU时间。
调度器通常分为长期调度器、中期调度器和短期调度器。
4. 调度算法调度算法是决定进程调度顺序的关键。
常见的调度算法包括先来先服务、最短作业优先、优先级调度、时间片轮转等。
不同的调度算法适用于不同的场景，需要根据具体的系统需求进行选择。
5. 进程优先级进程优先级是调度算法中常用的一个概念。
通过设定不同的优先级，可以确保高优先级的进程能够得到更多的CPU时间，从而提高系统的响应速度。
但是，过高的优先级也可能导致低优先级进程饥饿的问题，需要做出平衡。
6. 时间片轮转调度时间片轮转调度是一种常见的调度算法，主要用于多道程序设计环境中。
它将进程按照先来先服务的原则排成一个队列，并为每个进程分配一个时间片。
当时间片用完后，进程会被放到队列的尾部，等待下一次调度。
7. 多级反馈队列调度多级反馈队列调度是一种综合利用了时间片轮转和优先级调度的算法。
它将进程根据优先级分成多个队列，并为每个队列分配不同的时间片。
优先级高的队列拥有更短的时间片，从而提高高优先级进程的执行速度。
8. 作业调度作业调度是在长期调度过程中对进程进行排序并决定何时加载到内存中。
它通常会考虑系统资源、作业的运行时间和作业的优先级，以决定何时调度哪些作业。
9. 中期调度中期调度是对内存中的进程进行重新排序的过程，以释放内存空间并为新的进程腾出空间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验三实验报告课程名称计算机操作系统实验名称进程调度实验类型验证设计综合创新【实验目的】实验目的：（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。
（2）了解进程（线程）的调度机制。
（3）学习使用进程（线程）调度算法，掌握相应的与调度有关的API 函数。
实验要求：（1）经调试后程序能够正常运行。
（2）采用多进程或多线程方式运行，体现了进程或作业先来先服务、高优先权、按时间片轮转调度的关系。
（3）程序界面美观。
【实验内容】进程调度的算法:1)先来先服务算法：如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务（FCFS：first come first service）总是把当前处于就绪队列之首的那个进程调度到运行状态。
2)轮转法就是按一定时间片(记为q)轮番运行各个进程。
如果q 是一个定值，则轮转法是一种对各进程机会均等的调度方法。
3)优先级调度的基本思想是，把当前处于就绪队列中优先级最高的进程投入运行，而不管各进程的下一个CPU 周期的长短和其他因素。
实验步骤：（1）需求分析：了解基本原理，确定程序的基本功能，查找相关资料，画出基本的数据流图；（2）概要设计：确定程序的总体结构、模块关系和总体流程；（3）详细设计：确定模块内部的流程和实现算法；（4）上机编码和调试；（5）运行测试；（6）编写实验报告。
【实验环境】（含主要设计设备、器材、软件等）Pc 电脑一台 ，实验环境在实验结果截图中表明【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、流程图（1）先来先服务流程图不空空开 始初始化所有的JCB ，使JCB 作业提交的时刻的先后顺序排队时间量T1=0 调度队首的作业投入运行：更改队首指针，使作业的状态为R ，记住作业开始运行的时刻T 等等 计算并打印运行作业的完成时刻更改时间量T 的值 等待队列为空？ 计算并打印这个作业的平均周转时间及加权平均周转时间结 束（2）高优先权流程图Y开 始 初始化PCB ，输入进程信息 各进程优先级从高到低排列就绪队列为 结 束 就绪队列首进程投入运时间片到，运行进程已占用CPU 时间加1 使运行进程的优先级减1，把运行进程输入就绪队列 运行进程已占用CPU 时间已达到所需运行进程完成，撤销该进程（3）时间片轮转调度流程图系统初始化启动计数器读取DTMF编码、摘/挂机信号0->用户编号所有用户任务已调用？根据用户编号、子程序号调用相应任务指向下一用户（编号+1）发送DTFM编码定位时间已到？2、源代码（1）先来先服务//FCFS#include <stdio.h>#include <stdlib.h>float t,d; /*定义两个全局变量*/struct /*定义一个结构体数组，包括进程的信息*/{int id;float ArriveTime;float RequestTime;float StartTime;float EndTime;float RunTime;float DQRunTime;int Status;}arrayT ask[4]; /*定义初始化的结构体数组*/GetTask()/*给结构体数组赋值，输入到达，服务时间*/{int i;float a;for(i=0;i<4;i++){arrayT ask[i].id=i+1;printf("input the number");printf("input the the ArriveTime of arrayT ask[%d]:",i); /*用户输入进程的时间，初始为零*/scanf("%f",&a);arrayT ask[i].ArriveTime=a;printf("input the RequestTime of arrayT ask[%d]:",i);scanf("%f",&a);arrayT ask[i].RequestTime=a;arrayT ask[i].StartTime=0;arrayT ask[i].EndTime=0;arrayT ask[i].RunTime=0;arrayT ask[i].Status=0; /*开始默认的标志位零*/}}int fcfs() /*定义FCFS 中寻找未执行的进程的最先到达时间*/{int i,j,w=0; /*在结构体数组中找到一个未执行的进程*/for(i=0;i<4;i++){if(arrayT ask[i].Status==0){t=arrayT ask[i].ArriveTime;w=1;}if(w==1)break;}for(i=0;i<4;i++) /*查找数组中到达时间最小未执行的进程*/{if(arrayT ask[i].ArriveTime<t&&arrayT ask[i].Status==0)t=arrayT ask[i].ArriveTime;} /*返回最小到达时间的数组的下标*/for(i=0;i<4;i++){if (arrayT ask[i].ArriveTime==t)return i;}}int sjf() /*定义FCFS 中寻找未执行的进程的最先到达时间*/{int i,x=0,a=0,b=0; /*判断是不是第一个执行的进程*/float g;for(i=0;i<4;i++){if(arrayT ask[i].Status==1){g=arrayT ask[i].EndTime;x=1;}}if(x==0) /*第一个执行的进程按FCFS*/{t=arrayT ask[0].ArriveTime;for(i=0;i<4;i++){if(arrayT ask[i].ArriveTime<t){t=arrayT ask[i].ArriveTime;a=i;}}return a;}else{for(i=0;i<4;i++){if(arrayT ask[i].EndTime>g)g=arrayT ask[i].EndTime;}for(i=0;i<4;i++){if(arrayT ask[i].Status==0&& arrayT ask[i].ArriveTime<=g){t=arrayT ask[i].RequestTime;a=i;b=1;} /*判断有没有进程在前个进程完成前到达*/}if(b!=0) /*有进程到达则按SJF*/{for(i=0;i<4;i++){if(arrayT ask[i].Status==0&&arrayT ask[i].ArriveTime<=g&&arrayT ask[i].RequestTime<t) {t=arrayT ask[i].RequestTime;a=i;}}return a;}else{ /*否则按FCFS*/for(i=0;i<4;i++){if(arrayT ask[i].Status==0)t=arrayT ask[i].ArriveTime;}for(i=0;i<4;i++){if(arrayT ask[i].Status==0&&arrayT ask[i].ArriveTime<t){t=arrayT ask[i].ArriveTime;a=i;}}return a;}}}new(int s) /*定义执行进程后相关数据的修改*/{int i,g=0;for(i=0;i<4;i++){if(arrayT ask[i].Status==0)continue;else{g=1;break;}}if(g==0) /*当处理的是第一个未执行的进程时执行*/{arrayT ask[s].StartTime=arrayTask[s].ArriveTime;arrayT ask[s].EndTime=arrayT ask[s].RequestTime+arrayT ask[s].ArriveTime;arrayT ask[s].RunTime=arrayT ask[s].RequestTime;arrayT ask[s].Status=1;g=2;}if(g==1) /*当处理的不是第一个未执行的进程时执行*/{arrayT ask[s].Status=1;for(i=0;i<4;i++){if(arrayT ask[i].Status==1)d=arrayT ask[i].EndTime;}for(i=0;i<4;i++) /*查找最后执行的进程的完成时间*/{if(arrayT ask[i].EndTime>d&&arrayT ask[i].Status==1)d=arrayT ask[i].EndTime;}if(arrayT ask[s].ArriveTime<d) /*判断修改的进程的到达时间是否在前一个执行的进程的完成时间前面*/arrayT ask[s].StartTime=d;elsearrayT ask[s].StartTime=arrayT ask[s].ArriveTime;arrayT ask[s].EndTime=arrayT ask[s].StartTime+arrayTask[s].RequestTime;arrayT ask[s].RunTime=arrayT ask[s].EndTime-arrayT ask[s].ArriveTime;}arrayT ask[s].DQRunTime=arrayT ask[s].RunTime/arrayTask[s].RequestTime;}Printresult(int j) /*定义打印函数*/{printf("%d\t",arrayT ask[j].id); //%dprintf("%5.2f\t",arrayT ask[j].ArriveTime);printf("%5.2f\t",arrayT ask[j].RequestTime);printf("%5.2f\t",arrayT ask[j].StartTime);printf("%5.2f\t",arrayT ask[j].EndTime);printf("%5.2f\t",arrayT ask[j].RunTime);printf("%5.2f\n",arrayT ask[j].DQRunTime);}main(){int i,b,k;char a;int d[4];int c=0;system("clsr");printf("\t F. FCFS \n");printf("\t S. SFJ \n");printf("\t Q. EXIT \n");for(i=0;;i++){if(c)break;printf("please input the number a:\n");scanf("%s",&a);switch(a){case 'Q': c=1;break;case 'F':printf("please input the different-ArriveTime of arrayT asks\n");GetTask();printf("*****************************the result of fcfs\n");printf("Number\tArrive\tServer\tStart\tFinish\tTurnove\tTake power turnover time\n");for(b=0;b<4;b++) /*调用两个函数改变结构体数的值*/{k=fcfs();d[b]=k;new(k);}for(b=0;b<4;b++)Printresult(d[b]);/*调用打印函数打出结果*/continue;case 'S':printf("please input the different-RequestTime of arrayT asks\n");GetTask();printf("******************************the result of sjf\n");printf("Number\tArrive\tRequest\tStart\tEnd\tRun\tDQRun time\n");for(b=0;b<4;b++){k=sjf();d[b]=k;new(k);}for(b=0;b<4;b++)Printresult(d[b]);continue;default:printf("the number Error.please input another number!\n");}}}（2）时间片轮转//时间片轮转#include"string.h"#include "stdio.h"//#include "conio.h"//#include "graphics.h"#include<stdlib.h>//#define NULLtypedef struct quen /*定义结构*/{char pname[8];int time1;int time2;char state;struct quen *next;} QUEN;main()/*主程序*/{QUEN *q,*p,*head,*m;char str[8],f;int t,d,n;//r();/*textmode(C80);textbackground(0);textcolor(15);*/printf("Enter the maxnumber of nodes(n):\n");/*输入进程数*/scanf("%d",&n);d=n;if(d>0){printf("enter thepname:");scanf("%s",str);printf("enter the need time:");scanf("%d",&t);head=p=(QUEN *)malloc(sizeof(QUEN));strcpy(p->pname,str);p->time1=t;p->time2=0;p->state='R';p->next=NULL;head=p;getchar();--d;}while(d>0) {/*构建队列表*/printf("enter the pname:");scanf("%s",str);printf("enter need time:");scanf("%d",&t);q=(QUEN *)malloc(sizeof(QUEN));strcpy(q->pname,str);q->time1=t;q->time2=0;q->state='R';q->next=NULL;p->next=q;p=q;--d;p->next=head;q=head;}printf("process name need time runned static\n");do{printf(" %s%d %d %c\n",q->pname,q->time1,q->time2,q->state);q=q->next;}while(q!=head);printf("\n");do{if(head->time2<head->time1){head->time2++;if(head->time2==head->time1){head->state='E';q=head;//textbackground(0);printf("The running process is %s\n",q->pname);printf("process name left time runned static\n");do{//textcolor(15);/*输入队列表*/printf(" %s %d %d %c\n",q->pname,q->time1,q->time2,q->state);q=q->next;}while(q!=head);printf("\n");head=head->next;q=head;p->next=head;}else{printf("The running process is %s\n",q->pname);printf("process name left time runned static\n");do {printf("%s%d%d %c\n",q->pname,q->time1,q->time2,q->state);q=q->next;}while(q!=head);printf("\n");head=head->next;q=head;p=p->next;}printf("Is it needing new process?(y or n)\n");/*是否加入新的进程*/getchar();scanf("%c",&f);if(f=='Y'||f=='y'){getchar();printf("Enter the new pname:");scanf("%s",str);printf("Enter the new neededtime:");scanf("%d",&t);m=(QUEN *)malloc(sizeof(QUEN));strcpy(m->pname,str);m->time1=t;m->time2=0;m->state='R';m->next=NULL;if(q->next->state=='E'){p=m;head=m;p->next=head;q=head;}else{p->next=m;m->next=head;p=m;}}}}while(q->next->state!='E');printf("The processes are finished\n"); }（3）优先级调度//优先级调度#include <stdio.h>#include<stdlib.h>#include<string.h>//#include "conio.h"typedef struct pcb/*定义结构*/{ char name[5];struct pcb *next;int needtime;int priority;char state[5];}NODE;NODE *create_process(int n)/*创建队列*/ {NODE *head,*s,*t;int time,i=0,j;char pname[5];head=(NODE *)malloc(sizeof(NODE));printf("please input process name:");scanf("%s",pname);strcpy(head->name,pname);printf("please input need time:");scanf("%d",&time);head->needtime=time;printf("please input priority:");scanf("%d",&j);head->priority=j;strcpy(head->state,"ready");head->next=NULL;t=head;for(i=1;i<n;i++){s=(NODE *)malloc(sizeof(NODE));printf("please input process name:");getchar();gets(pname);strcpy(s->name,pname);printf("please input need time:");scanf("%d",&time);s->needtime=time;printf("please input priority:");scanf("%d",&j);s->priority=j;strcpy(s->state,"ready");s->next=NULL;t->next=s;t=s;}return head;}pri_process(NODE *p)/*输出进程队列*/{ int i;NODE *q;q=p->next;printf("\n name\tneedtime\tpriority \t state\n");while(q!=NULL){printf("%5s\t %2d \t %2d \t %5s \n",q->name,q->needtime,q->priority,q->state);q=q->next;}}NODE *order(NODE *head_sort)/*对进程的优先级进行排序*/{NODE *p,*s,*q,*head,*r,*t;int m,pr;char name[5];head=head_sort;p=head->next;r=p;t=p;q=p->next;while(r!=NULL){ while(q!=NULL){ if(p->priority<q->priority){m=p->priority;p->priority=q->priority;q->priority=m;strcmp(name,p->name);strcmp(p->name,q->name);strcmp(q->name,name);pr=p->needtime;p->needtime=q->needtime;q->needtime=pr;}p=q;q=q->next;}r=r->next;p=t;q=p->next;}return(head_sort);}main()/*主程序*/{NODE *p,*head,*m,*z,*n;p=(NODE *)malloc(sizeof(NODE));head=(NODE *)malloc(sizeof(NODE));m=(NODE *)malloc(sizeof(NODE));z=(NODE *)malloc(sizeof(NODE));n=(NODE *)malloc(sizeof(NODE));int j,time,x=0;char c,pname[5];//clrscr();system("clear");printf("please input process number!");scanf("%d",&x);p=create_process(x);head->next=p;pri_process(head);getchar();while(x>0){order(head);m=head->next;strcpy(m->state,"run");if(m->priority>=2)m->priority--;m->needtime--;if(head->next!=NULL)pri_process(head);if(m->needtime==0){head->next=m->next;printf("%s has finished\n",m->name);free(m);x--;}getchar();}//textmode(C80);//textbackground(0);//textcolor(4);printf("over!");getchar();}【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见）1、FCFS结果（虚拟机+Ubuntu）2、时间片轮转（虚拟机+Ubuntu）由于第一个进程命名后输入的时间为浮点型，导致后面的没有正常执行，第二个进程的名字便为0。