下载文档原格式
实验一，进程调度实验一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解.二、实验内容及要求1.编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
可以采用静态或动态最高优先数优先的算法。
2、编写并调试一个模拟的进程调度程序，采用简单轮转法和多队列轮转法的“轮转法”调度算法对五个进程进行调度。
三、实验主要仪器设备和材料硬件环境：LBM-PC或兼容机软件坏境：C语言编程环境四、实验设计方案及原理每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W (Wait).运行R (Rim)、或完成F (Finish)三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
(静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变；动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1或者，进程等待的时间超过某一时限时增加其优先数的值，等等。
) 简单轮转法的基本思想是：所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还为完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。
直至所有的进程运行完毕。
多队列轮转法的基本思想是：设置多个就绪队列，每个队列的优先级不同，每个队列的CPU 时间片人小不等：一个新的进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度：仅当第一队列空闲时，调度程序才调度第二队列中的进程运行，后面的队列同理。
实验一进程调度实验专业：信息管理与信息系统学号：2014******姓名：陈*实验日期：2016年11月11日一、实验目的通过本实验，采用动态优先权优先的调度算法编写和调试一个简单的进程调度程序，加深理解了有关进程控制块、进程队列的概念，并体会了优先权调度算法的具体实施办法。
二、实验要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三、实验方法内容1.算法设计思路（流程图）开始输入所有进程到一个链表中是否所有进程都已完成结束Yi = 1,m = 0在就绪队列中找到优先级最高的进程，用P1表示，state 设为R用P2指向链表第一个节点P2所指进程state = F ？NP2所指进程state = R ？NPriority – 2，CPUTime + 1，AllTime –1，YAllTime = 0？YNState 设为F ，m = 1CPUTime % StartBlock = 0 ？state 设为B ，m = 1YNP2所指进程state = B ？BolckTime - 1BlockTime = 0?State 设为 W YYN P2所指进程state = W ？NPriority + 1YNP2指向下一个节点P2已指向链表末尾？NYM = 1 ？i <= 2 ?i + 1YNNYNY2.算法中用到的数据结构（1）首先定义一个结构体，用以保存一个进程的各种信息，最后一个指针便于将所有进程形成一个链表typedef struct pcb{int id;int arriveTime; //到达时间int priority;int cpuTime;int allTime;int startBlock;int blockTime;char state;struct pcb *next;}PCB;（2）接着建立一个链表存储所有进程，以结构体PCB为节点（头节点为空节点，从第二个节点开始存储数据）。
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。
三、实验过程。
1. 先来先服务（FCFS）调度算法。
先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。
在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。
实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。
2. 最短作业优先（SJF）调度算法。
最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。
在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。
实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。
3. 时间片轮转（RR）调度算法。
时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。
在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。
实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。
4. 多级反馈队列（MFQ）调度算法。
多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。
在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。
实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。
四、实验总结。
通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。
《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
2.实验内容：用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。
3.设计实现：要求给出设计源码，设计源码要有详细注释，#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。
1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。
2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。
3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。
4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。
五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。
b. SJF算法：优先调度运行时间最短的进程。
c. 优先级调度算法：根据进程的优先级进行调度。
d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。
4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。
b. 循环执行调度算法，将CPU分配给就绪队列中的进程。
c. 更新进程状态，统计进程执行时间、等待时间等指标。
d. 当进程完成时，将其移至完成队列。
六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。
2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
第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("无效的调度算法选择。
操作系统实验一进程调度在计算机科学中，操作系统是管理计算机硬件与软件资源的程序，是计算机系统的内核与基石。
而进程调度作为操作系统的核心功能之一，对于系统的性能和资源利用率起着至关重要的作用。
本次操作系统实验一，我们将深入探讨进程调度的原理和实现。
进程，简单来说，是正在运行的程序的实例。
在多道程序环境下，多个进程可能同时竞争计算机系统的资源，如 CPU、内存、I/O 设备等。
进程调度的任务就是从就绪队列中选择一个合适的进程，并将 CPU 分配给它，以实现资源的合理分配和系统的高效运行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达就绪队列的先后顺序进行调度，这种算法简单直观，但可能导致短作业等待时间过长，从而影响系统的整体性能。
短作业优先算法则优先调度运行时间短的进程，能够有效降低平均等待时间，但可能对长作业不利，容易造成“饥饿”现象。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片的 CPU 使用权。
这种算法能够保证每个进程都能得到及时响应，但时间片的大小选择需要权衡系统的开销和响应时间。
优先级调度算法为每个进程赋予一个优先级，优先级高的进程优先获得 CPU 资源。
然而，确定合理的优先级以及避免低优先级进程“饥饿”是该算法需要解决的问题。
在实验中，我们通过模拟实现这些调度算法，来深入理解它们的工作原理和性能特点。
以时间片轮转算法为例，我们首先需要创建一个就绪队列来存放等待调度的进程。
每个进程包含进程 ID、所需运行时间、已运行时间等信息。
在调度过程中，从就绪队列头部取出一个进程，判断其剩余运行时间是否小于等于时间片。
如果是，则该进程运行完毕，从队列中删除；否则，将其已运行时间增加时间片大小，剩余运行时间减少时间片大小，然后将其移到队列尾部，等待下一轮调度。
通过对不同调度算法的模拟实验，我们可以观察到它们在不同场景下的表现。
第1篇一、实验目的通过本次实验，加深对操作系统进程调度过程的理解，掌握三种基本调度算法（先来先服务（FCFS）、时间片轮转、动态优先级调度）的原理和实现方法，并能够通过编程模拟进程调度过程，分析不同调度算法的性能特点。
二、实验环境1. 操作系统：Linux/Windows2. 编程语言：C/C++3. 开发环境：Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法：FCFS、时间片轮转、动态优先级调度。
2. 编写代码模拟进程调度过程，包括进程创建、进程调度、进程运行、进程结束等环节。
3. 每次调度后，打印当前运行的进程、就绪队列以及所有进程的PCB信息。
4. 编写实验报告，描述数据结构、算法流程，展示实验结果，并总结心得。
四、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。
2. 实现进程调度函数，根据所选调度算法进行进程调度。
3. 编写主函数，初始化进程信息，选择调度算法，并模拟进程调度过程。
4. 每次调度后，打印当前运行的进程、就绪队列以及所有进程的PCB信息。
5. 编写实验报告，描述数据结构、算法流程，展示实验结果，并总结心得。
五、实验结果与分析1. FCFS调度算法实验结果：按照进程到达时间依次调度，每个进程结束后，调度下一个进程。
分析：FCFS调度算法简单，易于实现，但可能会导致进程的响应时间较长，特别是当有大量进程到达时，后到达的进程可能会长时间等待。
2. 时间片轮转调度算法实验结果：每个进程完成一个时间片后，放弃处理机，转到就绪队列队尾。
分析：时间片轮转调度算法能够保证每个进程都能得到一定的运行时间，但可能会出现进程饥饿现象，即某些进程长时间得不到运行。
3. 动态优先级调度算法实验结果：每个进程完成一个时间片后，优先级减1，插入到就绪队列相关位置。
分析：动态优先级调度算法能够根据进程的运行情况动态调整优先级，使得优先级高的进程能够得到更多的运行时间，从而提高系统的响应速度。
操作系统实验报告实验一：进程调度实验学号 2015141443031姓名专业通信工程日期 2016.12.12 、一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、进程调度1、进程的状态2、进程的结构——PCB进程都是由一系列操作（动作）所组成，通过这些操作来完成其任务。
因此，不同的进程，其内部操作也不同。
在操作系统中，描述一个进程除了所需要的程序外，最主要的是需要一个与动态过程想联系的数据结构，该数据结构用来描述进程的外部特性（名字、状态等）以及与其他进程的（通信关系）等信息，该数据结构称为进程控制块（PCB、Process Control Block）。
进程控制块PCB与进程一一对应，PCB中记录了系统所需的全部信息、用于描述进程状况所需的全部信息和控制运行所需的全部信息。
因此，系统可以通过进程的PCB来对进程进行管理。
三、试验内容设计一个有N个进程共行的进程调度程序。
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数以及需要的运行时间可以实现人为的指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W(Wait）、运行R(Run）、或完成F(Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加一来表示。
如果运行一个时间片后，进程的已占用CPU 时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后进程的已占用CPU 时间还未达到所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减一（即降低一级），然后把它插入就绪队列等待CPU。
