实验三进程调度蔡凤武

实验一进程调度实验专业：信息管理与信息系统学号：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为节点（头节点为空节点，从第二个节点开始存储数据）。

华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：2011-12-9实验2进程调度进程完成，撤消该进程就绪队列首进程投入运行 时间片到，运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

（2）了解Windows2000/XP 中进程（线程）的调度机制。

（3）学习使用Windows2000/XP 中进程（线程）调度算法，掌握相应的与调度有关的Win32 API 函数。

【实验内容】在Windows XP 、Windows 2000等操作系统下，使用的VC 、VB 、java 或C 等编程语言，利用相应的WIN32 API 函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。

【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、进程调度算法：采用多级反馈队列调度算法。

其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。

当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS 原则等待调度执行，以此类推。

2、实验步骤:（1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。

（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。

（5）重复步骤（2）、（3）、（4），直到就绪队列为空。

操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。

在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。

本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。

一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。

进程调度的目标是提高系统的吞吐量、响应时间和公平性。

在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。

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

这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。

2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。

这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。

3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。

当一个进程的时间片用完后，它将被挂起，等待下一次调度。

这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。

4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。

这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。

三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。

进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。

二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。

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

先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。

这种算法简单直观，但可能导致短作业等待时间过长。

短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。

时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。

如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。

优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。

四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。

2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。

从就绪队列中取出第一个进程进行调度执行，直到其完成。

3、实现短作业优先算法计算每个进程的剩余服务时间。

将进程按照剩余服务时间从小到大排序，放入就绪队列。

从就绪队列中取出剩余服务时间最短的进程进行调度执行。

4、实现时间片轮转算法设定时间片大小。

将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。

进程在时间片内未完成的，放回就绪队列末尾。

5、实现优先级调度算法为每个进程设置优先级。

将进程按照优先级从高到低排序，放入就绪队列。

从就绪队列中取出优先级最高的进程进行调度执行。

6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。

第三章￿程控制与程调度《计算机操作系统实验指导》内容Linux程介绍Linux程控制函数介绍 实验三.一程地创建 Linux程调度实验三.二程地调度Linux程介绍Linux程（一）互程:由一个shell启动地程。

互程既可在前台运行,也可以在后台运行,前者称为前台程,后者称为后台程。

（二）批处理程:这种程与终端没有联系,是一个程系列,由多个程按照指定地方式执行。

（三）守护程（Daemon）:运行在后台地一种特殊程,它在系统启动时启动,并在后台运行。

Linux PCBC结构:task_structpid t_pid; /* process identifier */long state; /* state of the process */unsigned int time_slice /* scheduling information */struct task_struct *parent; /* this process’s parent */struct list_head children; /* this process’s children */ struct files_struct *files; /* list of open files */struct mm_struct *mm; /* address space of this process ……Linux程状态运行态（TASK_RUNNING）:程准备运行,或正在运行可断等待态（TASK_INTERRUPTIBLE）:程等待特定可断等待态（TASK_UNINTERRUPTIBLE）:程处于等待状态,但是此刻程是不可断地僵尸态（TASK_ZOMBIE）:程已经停止运行,但在内存仍有结构(task_struct)停止态（TASK_STOPPED/ TASK_TRACED ）:程暂停状态Linux三种资源拷贝方式ü享ü享同一资源,如虚存空间,文件等。

实验三进程调度实验目的1、理解有关进程控制块、进程队列的概念。

2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

实验内容与基本要求1、设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。

2、建立进程就绪队列。

3、编制两种进程调度算法：优先权调度算法和时间片轮转调度算法。

实验报告内容一．优先权调度算法和时间片轮转调度算法原理。

对于优先权调度算法，其关键是在于是采用静态优先权还是动态优先权，以及如何确定进程的优先权。

静态优先权是在创建进程是确定的，并且规定它在进程的整个运行期间保持不变。

动态优先权要配合抢占调度方式使用，它是指在创建进程时所赋予的优先权，可以随着进程的推进而发生改变，以便获得更好的调度性能。

在就绪队列中等待调度的进程，可以随着等待时间的增加，其优先权也以某个速率增加。

因此，对于优先权初值很低的进程，在等待足够时间后，其优先权也可能升为最高，从而获得调度，占用处理器并执行。

对已时间片轮转调度算法，系统将所有的就绪进程按进路就绪队列的先后次序排列。

每次调度时把CPU分配给队首进程，让其执行一个时间片，当时间片用完，由计时器发出时钟中断，调度程序则暂停改程序的执行，使其退出处理器，并将它送人就绪队的末尾，等待下一轮调度执行。

然后，把cpu 分配给就绪队列中新的队首进程，同时让它执行一个时间片。

二．程序流程图。

三．程序及注释。

#include <stdio.h>#include <dos.h>#include <stdlib.h>#include <conio.h>#include <iostream.h>#include <windows.h>#define P_NUM 5#define P_TIME 50enum st {ready,execute,block,finish};//状态定义进程//struct pcb{char name[4];//进程名字//int priority;//进程优先权//int cputime;//CPU运行时间//int needtime;//进程运行需要的时间//int count;//进程执行次数//int round;//时间片轮转轮次//st process;//进程状态//pcb *next;};//定义进程//pcb *get_process(){ pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl;while(i<P_NUM){ q=(struct pcb*)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime;q->cputime=0;q->priority=P_TIME-q->needtime;q->process=ready;q->next=NULL;if(i==0){ p=q;t=q;}else {t->next=q;t=q;}i++;}return p;//输入模拟测试的进程名和执行所需的时间，初始设置可模拟5个进程的调度//}void display (pcb *p){cout<<"name"<<" "<<"cputime"<<" "<<"needtime"<<" "<<"priority"<<" "<<"st"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->priority;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}//显示模拟结果，包含进程名，cpu的时间。

一、实验目的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、设计进程控制块PCB表结构，分别适⽤优先数调度算法和循环时间⽚轮转算法。

2、PCB结构通常包括以下信息：进程名、进程优先数、轮转时间⽚、进程的CPU时间，进程状态等。

根据调度算法不同，PCB结构可作适当的调整。

3、建⽴进程队列。

对不同的算法编制不同的⼊链程序编制两种进程调度算法：a、优先数调度；b、循环时间轮转调度三、实验设计1.实验原理：2.算法思想：以时间⽚为计量单位A：优先数调度算法1）系统初始化时给每⼀个进程赋⼀个NEEDTIME和初始PRI。

并按优先数⼊队。

2）系统每次选定⼀个优先级最⾼的进程投⼊运⾏，进程每执⾏⼀次，优先数减2，并将它的进程占⽤的CPU时间加10，进程到完成还要的CPU时间减10。

3）每当⼀个进程运⾏⼀个时间⽚后,系统根据它的CPUTIME来判断它是否已经结束,若CPUTIME>0,那么将它重新排⼊就绪队列。

4）如果系统中尚有进程没有运⾏完毕,那么转⼊2）。

B：循环时间⽚轮转算法1）系统初始化时给每⼀个进程赋以⼀个NEEDTIME，并将所有进程按进⼊的次序排成⼀个队列。

2）取队头进程,并投⼊运⾏。

3）采⽤相对固定时间⽚（ROUND），进程每执⾏⼀次，进程占⽤的CPU时间加ROUND，进程到完成还要的CPU时间减ROUND。

并排到就绪队列的尾部。

4）如果当前进程的NEEDTIME>0,那么将它排到队尾。

5）如果尚有进程在队列中,那么转⼊2）3.编程语⾔、主要数据结构和意义使⽤VC6.0语⾔PCB结构：name 进程名pri /round 进程优先数/进程轮转时间⽚cputime 进程占⽤的CPU时间needtime 进程到完成还要的时间state 进程状态（假设状态为 Ready、Run、Finish）next 链指针void showlist(link,char*,int);//显⽰进程队列void instlist(link,link);//按优先数插⼊进程void appenlist(link,link);//按就绪先后加⼊进程link gethead(link);//取队⾸进程4.流程图(优先数算法)5. 源程序（含主要注释）#include "stdlib.h"#include "iostream.h"#include "string.h"const int MAX= 5;const int ROUND=2;const char *ITOA[10]={"0","1","2","3","4","5","6","7","8","9"}; typedef enum flag{Ready,Run,Finish}; struct pcb{public:char name[10];//进程名int pri; //进程优数int round; //进程轮转时间⽚int cputime; //进程占⽤的CPU时间int needtime; //进程到完成还要的CPU时间flag state; //进程状态struct pcb *next;//链指针};typedef struct pcb plist;{void showlist(link,char*,int);//显⽰进程队列void instlist(link,link);//按优先数插⼊进程void appenlist(link,link);//按就绪先后加⼊进程link gethead(link);//取队⾸进程int num=MAX+1;char str[10];link ptr,head1,head2;int i;int j=0;head1=new plist;head1->next=NULL;//就绪队⾸指针head2=new plist;head2->next=NULL;//完成队⾸指针while ((num>MAX)||(num<1)){// printf("请输⼊演⽰进程数\n");cout<<"请输⼊演⽰进程数:";// scanf("%d",&num);cin>>num;if (num>MAX) cout<<"输⼊的演⽰进程数太⼤！请输⼊⼩于等于5的数。

实验三、进程调度模拟程序实验一、实验目的用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

二、实验内容和要求设计一个有 N个进程并发执行的进程调度模拟程序。

用Ｃ＋＋模拟基于时间片的轮转算法、静态优先算法、动态优先算法、多级反馈队列调度算法。

三、实验方法、步骤及结果测试1.原理分析及流程图(1). 每个进程有一个进程控制块（PCB）表示。

进程控制块包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

(2). 进程的优先数及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。

(3). 每个进程的状态可以是就绪 r（ready）、运行R（Running）、或完成F（Finished）三种状态之一。

(4). 就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

(5). 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待调度。

(6). 每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB，以便进行检查。

(7). 重复以上过程，直到所要进程都完成为止。

2.主要程序段及其解释：动态优先调度：#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 24struct jcb{char name[10];int reqtime;int runtime;int startime;int fintime;int prio;char status;};typedef struct jcb JCB;void input(JCB job[],int *pnum){int num;int i;printf("process 数：");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个process:\n",i+1);printf("输入proc名：");scanf("%s",job[i].name);printf("Priority:");scanf("%d",&job[i].prio);printf("要求服务时间:");scanf("%d",&job[i].reqtime);job[i].status='r';job[i].runtime=0;}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;if (n==0){printf("the queue is null!!\n");return;}printf("\tname\tprio\trqtime\truntime\tstatus");for(i=0;i<n;i++){printf("\nN %d",i+1);printf("\t&s",jcbp[i].name);printf("\t&d",jcbp[i].prio);printf("\t&d",jcbp[i].reqtime);printf("\t&d",jcbp[i].runtime);printf("\t&c",jcbp[i].status);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++)for(i=0;i<n-j;i++)if(btjcb[i].prio<btjcb[i+1].prio){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}main(){JCB jobarrived[MAX],jobfinished[MAX];int numarr, numfin;int systime=0;int i,j,n;JCB jcbrunning;input(jobarrived,&numarr);numfin=0;systime=0;btsort (jobarrived,numarr);printf("经按priority排序后,read queue是\n");jcbprintf(jobarrived,numarr);do{btsort(jobarrived,numarr);printf("\n\n\t\t现在系统时间%d:\n\n",systime);printf("ready queue 有\n");jcbprintf(jobarrived,numarr);jcbrunning=jobarrived[0];numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jcbrunning.status='R';jcbrunning.startime=systime;printf("\n\n\t\t处于运行态的作业名%s\n",);systime++;jcbrunning.runtime++;if (jcbrunning.runtime==jcbrunning.reqtime){jobfinished[numfin]=jcbrunning;jobfinished[numfin].status='F';numfin++;}else{jcbrunning.prio--;jcbrunning.status='r';jobarrived[numarr]=jcbrunning;numarr++;}printf("\n\n\t\t系统时间：%d已经完成的有\n\n",systime);jcbprintf(jobfinished,numfin);getchar();getchar();}while((numarr!=0));printf("\nCompleted!! ByeBye!!");getchar();getchar();}2、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1); printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t运行时间");for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].reqtime); }}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d\n",job[i].name,job[i].reqtime,job[i].ru ntime);}}void main(){JCB jobarrived[MAX];int numarr,i;JCB jcbrunning;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后，就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");while(numarr>0){jcbrunning=jobarrived[0];jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");if(jcbrunning.reqtime>0){for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jobarrived[numarr-1]=jcbrunning;}else{numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int firsttime;int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序数目:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);printf("优先级:");scanf("%d",&jcb[i].firsttime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1);printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].firsttime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t优先级\t运行时间"); for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].firsttime); printf(" %d",jcbp[i].reqtime);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称优先级运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d %d\n",job[i].name,job[i].firstti me,job[i].reqtime,job[i].runtime);}}void main(){JCBjobarrived1[MAX],jobarrived2[MAX],jobarrived3[MAX],jobarrived[MAX]; int numarr1,numarr2,numarr3,numarr,i;JCB jcbrunning;numarr2=0;numarr1=0;numarr3=0;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后，就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}for(i=0;i<numarr;i++){jobarrived3[i]=jobarrived[i];numarr3++;}printf("\n.............就绪队列3是..........\n");jcbprintf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");jcbprintf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");jcbprintf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();while(numarr3>0){jcbrunning=jobarrived3[0];if(jcbrunning.firsttime==3){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1; jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");}jobarrived3[0]=jcbrunning;}if(jobarrived3[0].reqtime>0){jobarrived2[numarr2]=jobarrived3[0];numarr2++;}numarr3--;for(i=0;i<numarr3;i++){jobarrived3[i]=jobarrived3[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr2>0){jcbrunning=jobarrived2[0];if(jcbrunning.firsttime==2){if(jcbrunning.reqtime>2){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-2;jcbrunning.runtime=jcbrunning.runtime+2;printf("\n正在执行的进程名称是%s\n",);}else{jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime;jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime;printf("\n正在执行的进程名称是%s\n",); }jobarrived2[0]=jcbrunning;}if(jobarrived2[0].reqtime>0){jobarrived1[numarr1]=jobarrived2[0];numarr1++;}numarr2--;for(i=0;i<numarr2;i++){jobarrived2[i]=jobarrived2[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr1>0){jcbrunning=jobarrived1[0];if(jcbrunning.firsttime==1){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime; jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime; printf("\n正在执行的进程名称是%s\n",); }}numarr1--;for(i=0;i<numarr1;i++){jobarrived1[i]=jobarrived1[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3.运行结果及分析四、 实验总结这次的实验是我们这门课第一次以个人为单位来完成的实验，然后这次实验用了三个星期去完成，虽然每次上机课老师都会先讲，可是我还是不太懂，到自己做的时候又不会，都是照样画葫芦。

操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。

这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。

具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。

然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标，可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构，包括进程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，插入到就绪队列相关位置。

分析：动态优先级调度算法能够根据进程的运行情况动态调整优先级，使得优先级高的进程能够得到更多的运行时间，从而提高系统的响应速度。

进程调度实验报告进程调度实验报告一、引言进程调度是操作系统中重要的一个组成部分，它负责管理和分配系统资源给不同的进程，以实现系统的高效运行。

本次实验旨在通过实际操作和观察，深入理解进程调度算法的原理和应用。

二、实验目的1. 理解进程调度的概念和作用；2. 掌握常见的进程调度算法；3. 分析不同调度算法的优缺点。

三、实验环境本次实验使用的是Linux操作系统，并通过编写C语言程序来模拟进程的创建和调度过程。

四、实验过程1. 创建进程在实验开始时，我们首先编写了一个简单的C程序，用于创建多个进程。

通过调用系统函数fork()，我们可以实现进程的复制和创建。

在实验中，我们创建了5个子进程，并分别给它们设置了不同的优先级。

2. 进程调度算法的实现为了模拟不同的进程调度算法，我们在程序中实现了以下几种常见的调度算法：- 先来先服务（FCFS）：按照进程到达的先后顺序进行调度，即先到先服务。

- 短作业优先（SJF）：按照进程的执行时间进行排序，优先调度执行时间最短的进程。

- 优先级调度：按照进程的优先级进行排序，优先调度优先级最高的进程。

- 时间片轮转调度：将CPU时间分成若干个时间片，每个进程在一个时间片内执行，超过时间片后，将CPU让给下一个进程。

3. 实验结果分析通过运行程序，我们观察到不同调度算法下进程的执行情况，并进行了分析。

- 在先来先服务算法下，进程按照到达的先后顺序进行调度，执行时间较长的进程可能会导致其他进程的等待时间增加。

- 在短作业优先算法下，执行时间短的进程会被优先调度，可以减少平均等待时间，但可能会导致长作业的饥饿。

- 在优先级调度算法下，优先级高的进程会被优先调度，但如果优先级设置不合理，可能会导致低优先级进程长时间等待。

- 在时间片轮转调度算法下，每个进程被分配一个时间片，可以保证每个进程公平地获得执行机会，但如果时间片过小，会导致频繁的上下文切换。

五、实验总结通过本次实验，我们深入了解了进程调度的原理和应用。

操作系统实验实验三进程调度学号 1415251011 姓名黄天班级 14集成1班华侨大学电子工程系实验目的1、理解有关进程控制块、进程队列的概念。

2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

实验内容与基本要求1、设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。

2、建立进程就绪队列。

3、编制两种进程调度算法：优先权调度算法和时间片轮转调度算法。

实验报告内容1、优先权调度算法和时间片轮转调度算法原理。

优先权调度算法原理：（此处为静态优先权）当该算法用于作业调度时，系统从后备作业队列中选择若干个优先级最高的，且系统能满足资源要求的作业装入内存运行。

当该算法用于进程调度时，将把处理机分配给就绪进程队列中优先级最高的进程。

在这种调度方式下，系统一旦把处理机分配给就绪队列中优先级最高的进程后，该进程就能一直执行下去，直至完成；或因等待某事件的发生使该进程不得不放弃处理机时，系统才能将处理机分配给另一个优先级高的就绪进程。

时间片轮转调度算法原理：在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.4、运行结果以及结论。

1.优先权调度算法：这里采取的是短时间优先算法运行结果结果表明，占用时间最少得程序，最先运行，依次进行。

结论:程序很好的完成了实验要求所要达到的目标，进行短时间优先运行。

2.时间片轮转算法：每个时间片大小为1.每个程序轮转一次程序运行结果结论：程序运行结果表明，所有程序按照时间片来轮转，每个程序运行一个时间片后轮到下一个程序，直到所有程序运行完。

实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。

1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。

二. 实验属性该实验为设计性实验。

三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。

1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。

实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。

五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。

1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。

内容一：检查上次进程模拟实验情况；实验三进程调度【实验要求】1、复习进程的状态及其转换；2、深入理解同步与互斥的概念及p、v操作；3、了解进程调度的功能和算法；4、上机前仔细阅读参考程序，并在参考程序的基础上，对程序作相应的修改,修改后进行测试，给出最后的实验数据与测试结果。

【实验目的】进程调度是进程管理的主要内容之一，通过设计编程，调试一个简单的进程调度模拟程序，对进程调度，进程运行状态变换及PV操作加深理解和掌握。

【实验内容】1、模拟批处理多道操作系统的进程调度；采用剥夺式优先算法，对三个进程进行模拟调度2、模拟实现同步机构避免并发进程执行时可能与时间相关的错误；模拟PV操作同步机构，用PV操作解决进程进入临界区的问题。

【需修改的实验内容】这一部分内容要求同学们自己编程完成，并进行调试，给出相应的测试数据和测试结果1、将进程的优先级设为动态的优先数，用设置和计算两种方式实现；设置可以用一个设置函数完成，也可以用随机数；计算给出一个计算公式；2、在不修改优先数的基础上，请同学们将由p1先执行改为p3先执行，并进行测试；测试后与参考程序进行比较；给出比较结果。

3、在修改了优先数之后，请同学们将由p1先执行改为p3先执行，并进行测试；测试后与参考程序进行比较；给出比较结果。

【提示】（1）参考程序对三个进程进行模拟调度，对各进程的优先数静态设置，P1,P2,P3三个进程的优先数为1，2，3，并指定P1的优先数最高，P3的优先数最低，每个进程都处于执行态“e”，就绪态“r”，等待态“w”三种状态之一，并假定初始态为“r”。

（2）每一个进程有一个PCB，PCB的内容根据具体情况设置，这里共设置4个数据域，该系统在运行过程中能显示或打印各进程和参数的变化情况，以便观察各进程的调度；（3）参考程序在完成必要的初始化后，便进入进程调度程序，首先由P1进入执行，当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时，转进程调度。

一、实验目的通过对进程调度算法的设计，深入理解进程调度的原理。

进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。

进程调度分配处理机，是控制协调进程对CPU的竞争，即按一定的调度算法从就绪队列中选中一个进程，把CPU的使用权交给被选中的进程。

进程通过定义一个进程控制块的数据结构（PCB）来表示；每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性；在RR中，以1为时间片单位；运行时，输入若干个进程序列，按照时间片输出其执行序列。

二、实验环境VC++三、实验内容实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR）[提示]：(1) 先来先服务（FCFS）调度算法原理：每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。

该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。

将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，是一种最普遍和最简单的方法。

它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短。

按照就绪进程进入就绪队列的先后次序进行调度，简单易实现，利于长进程，CPU繁忙型作业，不利于短进程，排队时间相对过长。

(2) 时间片轮转调度算法RR原理：时间片轮转法主要用于进程调度。

采用此算法的系统，其程序就绪队列往往按进程到达的时间来排序。

进程调度按一定时间片（q）轮番运行各个进程.进程按到达时间在就绪队列中排队，调度程序每次把CPU分配给就绪队列首进程使用一个时间片，运行完一个时间片释放CPU，排到就绪队列末尾参加下一轮调度，CPU分配给就绪队列的首进程。

固定时间片轮转法：1 所有就绪进程按FCFS 规则排队。

2 处理机总是分配给就绪队列的队首进程。

3 如果运行的进程用完时间片，则系统就把该进程送回就绪队列的队尾，重新排队。