操作系统进程管理与调度的模拟

合集下载

操作系统实验报告进程管理

操作系统实验报告进程管理

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

进程管理是操作系统的重要功能之一,它负责对计算机中运行的各个进程进行管理和调度,以保证系统的高效运行。

本实验报告将介绍进程管理的基本概念、原理和实验结果。

一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例,它拥有独立的内存空间和执行环境。

线程是进程中的一个执行单元,多个线程可以共享同一个进程的资源。

进程和线程是操作系统中最基本的执行单位。

2. 进程状态进程在运行过程中会经历不同的状态,常见的进程状态包括就绪、运行和阻塞。

就绪状态表示进程已经准备好执行,但还没有得到处理器的分配;运行状态表示进程正在执行;阻塞状态表示进程由于某些原因无法继续执行,需要等待某些事件的发生。

3. 进程调度进程调度是操作系统中的一个重要任务,它决定了哪个进程应该获得处理器的使用权。

常见的调度算法包括先来先服务(FCFS)、最短作业优先(SJF)和时间片轮转等。

二、进程管理的原理1. 进程控制块(PCB)PCB是操作系统中用于管理进程的数据结构,它包含了进程的各种属性和状态信息,如进程标识符、程序计数器、寄存器值等。

通过PCB,操作系统可以对进程进行管理和控制。

2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。

进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。

进程的创建和撤销是操作系统中的基本操作之一。

3. 进程同步与通信多个进程之间可能需要进行同步和通信,以实现数据共享和协作。

常见的进程同步与通信机制包括互斥锁、信号量和管道等。

三、实验结果与分析在本次实验中,我们使用了一个简单的进程管理模拟程序,模拟了进程的创建、撤销和调度过程。

通过该程序,我们可以观察到不同调度算法对系统性能的影响。

实验结果显示,先来先服务(FCFS)调度算法在一些情况下可能导致长作业等待时间过长,影响系统的响应速度。

实验三 模拟进程调度

实验三   模拟进程调度

实验三模拟进程调度一实验目的理解操作系统进程管理中进行进程调度的过程和编程方法,掌握先来先服务调度算法和最高优先数优先的调度算法,创建进程控制块PCB。

理解进程的状态及变化,动态显示每个进程的当前状态及进程的调度情况二实验要求编写一个允许多个进程并发执行的进程调度程序。

1)进程调度算法:进程的调度采用最高优先数优先的调度算法和先来先服务调度算法相结合的算法,并且采用动态优先数策略,选择进程占用处理器后该进程仅能使用一个时间片,运行完后优先数减1。

2)每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3)进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为输入进程的时间。

4)进程的运行时间以时间片为单位进行计算。

5)每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

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

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

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

8)每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止三概要设计进程控制块:描述进程的状态信息,用结构体定义typedef struct process{ char name[10]; //进程名int priority; //优先数Time ReachTime; //到达时间Time NeedTime; //需要运行时间Time UsedTime; //已用时间char state; //进程状态}PCB; //进程控制块图1.进程调度模拟程序模块图算法思想:定义结构体PCB描述进程的进程控制块,定义数组PCB pcb[Max]存放进程。

操作系统实验二:进程管理

操作系统实验二:进程管理

操作系统实验二:进程管理操作系统实验二:进程管理篇一:操作系统实验报告实验一进程管理一、目的进程调度是处理机管理的核心内容。

本实验要求编写和调试一个简单的进程调度程序。

通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。

二、实验内容及要求1、设计进程控制块PCB的结构(PCB结构通常包括以下信息:进程名(进程ID)、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。

可根据实验的不同,PCB结构的内容可以作适当的增删)。

为了便于处理,程序中的某进程运行时间以时间片为单位计算。

各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。

2、系统资源(r1…rw),共有w类,每类数目为r1…rw。

随机产生n进程Pi(id,s(j,k)t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间,在运行过程中,会随机申请新的资源。

3、每个进程可有三个状态(即就绪状态W、运行状态R、等待或阻塞状态B),并假设初始状态为就绪状态。

建立进程就绪队列。

4、编制进程调度算法:时间片轮转调度算法本程序用该算法对n个进程进行调度,进程每执行一次,CPU时间片数加1,进程还需要的时间片数减1。

在调度算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了1个单位),这时,CPU时间片数加1,进程还需要的时间片数减1,并排列到就绪队列的尾上。

三、实验环境操作系统环境:Windows系统。

编程语言:C#。

四、实验思路和设计1、程序流程图2、主要程序代码//PCB结构体struct pcb{public int id; //进程IDpublic int ra; //所需资源A的数量public int rb; //所需资源B的数量public int rc; //所需资源C的数量public int ntime; //所需的时间片个数public int rtime; //已经运行的时间片个数public char state; //进程状态,W(等待)、R(运行)、B(阻塞)//public int next;}ArrayList hready = new ArrayList();ArrayList hblock = new ArrayList();Random random = new Random();//ArrayList p = new ArrayList();int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数,n为初始化进程个数//r为可随机产生的进程数(r=m-n)//a,b,c分别为A,B,C三类资源的总量//i为进城计数,i=1…n//h为运行的时间片次数,time1Inteval为时间片大小(毫秒)//对进程进行初始化,建立就绪数组、阻塞数组。

全国自考操作系统(进程管理)模拟试卷1(题后含答案及解析)

全国自考操作系统(进程管理)模拟试卷1(题后含答案及解析)

全国自考操作系统(进程管理)模拟试卷1(题后含答案及解析) 题型有:1. 单项选择题 3. 填空题 4. 简答题 6. 判断题单项选择题1.下列作业调度算法中,作业平均周转时间最短的是_______。

A.先来先服务法B.短作业优先法C.优先数法D.时间片轮转法正确答案:B 涉及知识点:进程管理2.作业调度程序从处于_______态的队列中选取适当的作业调入主系统。

A.就绪B.提交C.后备D.等待正确答案:C 涉及知识点:进程管理3.一个进程_______必定会引起进程切换。

A.被创建后进入就绪态B.收到软中断信号后C.从运行态变为阻塞态D.从阻塞态变为就绪态正确答案:C 涉及知识点:进程管理4.一个运行的进程用完了分配给它的时间片后,它的状态转变为_______态。

A.阻塞B.睡眠C.就绪D.终止正确答案:C解析:一个运行的进程用完了分配给它的时间片,说明它本身逻辑上还能执行,且还需执行,它的状态转变为就绪状态。

知识模块:进程管理5.在UNIX系统中,下列proc结构的成员中与进程图像的调入有关的是_______。

A.p_sigB.p_timeC.p_cpuD.p_nice正确答案:B解析:进程图像的换入算法是找出在盘交换区的就绪进程,按它们在外存驻留时间p_time从长到短的次序逐个将它们换入内存,直至全部调入或内存无足够空闲区为止。

知识模块:进程管理6.CPU的执行状态分为系统态和用户态,从用户态转换到系统态的唯一途径是通过_______。

A.修改程序状态字B.中断屏蔽C.系统调用D.进程调度程序正确答案:C 涉及知识点:进程管理7.UNIX系统中,在下列的_______情况时,设置runrun标志。

A.进程因等待某一事件进入了高低优先权睡眠状态B.进程将盘交换区的SRUN状态进程调入内存C.在唤醒睡眠进程时,发现该进程优先数比curpri小D.进程完成了预定任务,进入了SZOMB状态正确答案:C 涉及知识点:进程管理8.在UNIX系统中,当0号进程在sched函数中找不到合适的换出进程时,就将全局标志变量_______置位。

操作系统进程管理与调度

操作系统进程管理与调度

操作系统进程管理与调度随着计算机技术的不断发展,操作系统作为计算机系统的核心组成部分,起着重要的作用。

其中,进程管理与调度是操作系统的重要功能之一。

本文将探讨操作系统中的进程管理与调度相关的概念、原理、算法等内容。

一、进程管理概述进程是指计算机中正在运行的程序实例,是操作系统资源分配的基本单位。

进程管理包括进程的创建、撤销、状态转换、同步与通信等,是操作系统中的重要任务。

1. 进程的创建与撤销进程的创建是指在系统中产生一个新的进程,包括向系统申请资源、分配资源等步骤。

进程的撤销是指终止一个正在运行的进程,释放其所占用的系统资源。

2. 进程的状态转换进程在运行过程中会经历不同的状态,包括就绪态、运行态和阻塞态。

进程状态的转换是指进程在不同状态之间的切换过程,由操作系统根据不同的事件来进行调度和管理。

3. 进程的同步与通信多个进程之间需要进行数据的交换和相互合作,进程的同步与通信机制在这一过程中起到关键作用。

常见的进程同步与通信机制包括信号量、管程、消息传递等。

二、进程调度算法进程调度是操作系统中的一个重要功能,主要负责决定哪些进程可以占用处理器执行,以及在何时执行。

根据不同的调度策略和算法,可以实现不同的调度效果。

1. 先来先服务(FCFS)先来先服务是最简单的调度算法,按照进程到达的顺序进行调度。

当一个进程执行完毕或发生阻塞时,下一个进程按照就绪队列的顺序进行调度。

但是,FCFS算法容易产生“饥饿”现象,导致长作业等待时间过长。

2. 短作业优先(SJF)短作业优先调度算法是根据进程的执行时间进行调度,执行时间短的进程优先执行。

短作业优先算法可以减少平均等待时间,但是对于长作业可能会产生不公平现象。

3. 时间片轮转(RR)时间片轮转调度算法是按照时间片的大小进行调度,每个进程按照顺序执行一个时间片后,切换到下一个进程。

时间片轮转算法可以保证每个进程都能得到一定的执行机会,但是对于长时间运行的进程可能效果较差。

进程的管理实验报告结论

进程的管理实验报告结论

一、实验背景及目的进程是操作系统中基本的活动单位,进程管理是操作系统核心功能之一。

为了深入理解进程的概念、进程状态转换、进程同步与互斥等知识,我们进行了进程管理实验。

本次实验旨在通过编写程序,模拟进程的创建、调度、同步与互斥等操作,加深对进程管理的理解。

二、实验内容及方法1. 进程创建与状态转换(1)使用系统调用fork()创建子进程,观察父进程和子进程的状态转换过程。

(2)使用系统调用exec()替换子进程的内容,观察子进程状态变化。

2. 进程调度(1)编写进程调度程序,实现最高优先数优先调度算法和先来先服务调度算法。

(2)模拟进程就绪队列,观察调度算法对进程执行顺序的影响。

3. 进程同步与互斥(1)使用信号量实现进程同步,观察进程同步效果。

(2)使用互斥锁实现进程互斥,观察进程互斥效果。

4. 进程通信(1)使用管道实现进程间通信,观察通信效果。

(2)使用共享内存实现进程间通信,观察通信效果。

三、实验结果与分析1. 进程创建与状态转换实验结果显示,使用fork()创建子进程后,父进程和子进程的状态均为运行态。

当父进程调用exec()替换子进程内容后,子进程状态变为僵尸态,父进程状态变为运行态。

这说明进程在创建和替换过程中,其状态发生了相应的变化。

2. 进程调度实验结果显示,最高优先数优先调度算法和先来先服务调度算法均能正确执行。

最高优先数优先调度算法下,优先级高的进程先执行;先来先服务调度算法下,先到达的进程先执行。

这说明两种调度算法均能实现进程的合理调度。

3. 进程同步与互斥实验结果显示,使用信号量实现进程同步时,进程能正确地按照规定的顺序执行;使用互斥锁实现进程互斥时,进程能正确地实现互斥访问共享资源。

这说明信号量和互斥锁在进程同步与互斥方面具有重要作用。

4. 进程通信实验结果显示,使用管道实现进程间通信时,进程能正确地接收和发送数据;使用共享内存实现进程间通信时,进程能正确地访问共享内存中的数据。

模拟调度实验报告(3篇)

模拟调度实验报告(3篇)

第1篇一、实验背景进程调度是操作系统核心功能之一,它负责在多道程序环境下,按照一定的策略对进程进行调度,以确保系统资源的合理分配和高效利用。

为了加深对进程调度算法的理解,本次实验采用模拟的方式,实现了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种算法,并对实验过程进行了详细记录和分析。

二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。

2. 掌握进程控制块(PCB)的设计与实现。

3. 通过模拟实验,验证三种调度算法的执行效果。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验内容1. 定义进程控制块(PCB)进程控制块是操作系统用于描述和管理进程的实体,它包含了进程的基本信息。

本实验中,PCB包含以下字段:- 进程ID:唯一标识一个进程。

- 到达时间:进程进入就绪队列的时间。

- 需要运行时间:进程完成所需的时间。

- 已运行时间:进程已运行的时间。

- 状态:进程当前的状态(就绪、运行、阻塞、完成)。

2. 实现三种调度算法(1)先来先服务(FCFS)算法FCFS算法按照进程到达就绪队列的顺序进行调度,先到先服务。

具体实现如下:- 将进程按照到达时间排序,形成就绪队列。

- 遍历就绪队列,依次执行进程,直到进程完成或被阻塞。

(2)时间片轮转(RR)算法RR算法将CPU时间划分为时间片,每个进程运行一个时间片后,让出CPU,等待下一个时间片。

具体实现如下:- 设置一个时间片大小。

- 将进程按照到达时间排序,形成就绪队列。

- 遍历就绪队列,每个进程执行一个时间片,如果进程未完成,则将其加入就绪队列队尾。

(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度,优先级高的进程优先执行。

具体实现如下:- 设置一个优先级阈值,当进程的优先级高于阈值时,将其加入就绪队列。

- 遍历就绪队列,选择优先级最高的进程执行,直到进程完成或被阻塞。

操作系统进程调度实验报告

操作系统进程调度实验报告

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

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

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

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

二、实验环境本实验使用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、理解进程的基本概念、进程状态及转换。

2、掌握进程的创建、终止和调度方法。

3、观察和分析进程在运行过程中的资源消耗和调度行为。

4、分析操作系统对进程的资源分配和调度策略对系统性能的影响。

三、实验环境与工具本实验在Linux操作系统上进行,使用GNU/Linux环境下的工具进行进程的创建、监控和调度。

四、实验步骤与记录1、创建进程:使用shell命令“fork”创建一个新的进程。

记录下父进程和子进程的PID,以及它们在内存中的状态。

2、进程状态观察:使用“ps”命令查看当前运行进程的状态,包括进程的PID、运行时间、CPU使用率等。

同时,使用“top”命令实时监控系统的CPU、内存等资源的使用情况。

3、进程调度:在“crontab”中设置定时任务,观察系统如何根据预设的调度策略分配CPU资源给各个进程。

4、资源分配:通过修改进程的优先级(使用“nice”命令),观察系统如何调整资源分配策略。

5、终止进程:使用“kill”命令终止一个进程,并观察系统如何处理该进程占用的资源。

五、实验结果与分析1、创建进程:通过“fork”系统调用,成功创建了一个新的进程,并获取了父进程和子进程的PID。

在内存中,父进程和子进程的状态分别为“running”和“ready”。

2、进程状态观察:使用“ps”命令可以看到父进程和子进程的状态均为“running”,同时显示了它们的CPU使用率和运行时间等信息。

通过“top”命令,可以实时监控系统的CPU、内存等资源的使用情况,为进一步分析提供了数据支持。

3、进程调度:在“crontab”中设置定时任务后,系统会根据预设的调度策略以及各个进程的运行状态,动态地分配CPU资源给各个进程。

《操作系统》实验二

《操作系统》实验二

《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解,通过实际操作,提高对操作系统设计和实现的认知。

通过实验二,我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。

二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。

b.设计一个简单的进程调度算法,如轮转法或优先级调度法。

c.实现进程间的通信机制,如共享内存或消息队列。

2、线程调度a.实现线程的创建、撤销和调度。

b.实现一个简单的线程调度算法,如协同多任务(cooperative multitasking)。

3、内存管理a.设计一个简单的分页内存管理系统。

b.实现内存的分配和回收。

c.实现一个简单的内存保护机制。

4、文件系统a.设计一个简单的文件系统,包括文件的创建、读取、写入和删除。

b.实现文件的存储和检索。

c.实现文件的备份和恢复。

三、实验步骤1、进程管理a.首先,设计一个进程类,包含进程的基本属性(如进程ID、状态、优先级等)和操作方法(如创建、撤销、阻塞、唤醒等)。

b.然后,实现一个进程调度器,根据不同的调度算法对进程进行调度。

可以使用模拟的方法,不需要真实的硬件环境。

c.最后,实现进程间的通信机制,可以通过模拟共享内存或消息队列来实现。

2、线程调度a.首先,设计一个线程类,包含线程的基本属性(如线程ID、状态等)和操作方法(如创建、撤销等)。

b.然后,实现一个线程调度器,根据不同的调度算法对线程进行调度。

同样可以使用模拟的方法。

3、内存管理a.首先,设计一个内存页框类,包含页框的基本属性(如页框号、状态等)和操作方法(如分配、回收等)。

b.然后,实现一个内存管理器,根据不同的内存保护机制对内存进行保护。

可以使用模拟的方法。

4、文件系统a.首先,设计一个文件类,包含文件的基本属性(如文件名、大小等)和操作方法(如创建、读取、写入、删除等)。

b.然后,实现一个文件系统管理器,包括文件的存储和检索功能。

操作系统实训报告

操作系统实训报告

操作系统实训报告一、实训背景操作系统是计算机系统中最基本的软件之一,它负责管理计算机系统的各种资源,如内存、CPU、磁盘等。

为了更好地掌握操作系统的原理和实现,我们在课程中进行了一系列的操作系统实训。

二、实训内容1. 实验环境搭建在开始实验之前,我们需要先搭建好实验环境。

我们使用了虚拟机软件VMware Workstation来模拟一个计算机系统,并安装了Ubuntu 操作系统作为我们的实验平台。

2. 实验任务在本次实训中,我们主要完成了以下几个任务:(1)进程管理:通过编写一个简单的C程序来模拟进程创建、销毁和调度等操作。

(2)内存管理:通过编写一个简单的C程序来模拟内存分配和回收等操作。

(3)文件系统:通过使用Linux命令行工具来创建、读取和删除文件,并学习了文件权限管理等知识。

三、实训过程1. 进程管理首先,我们使用C语言编写了一个简单的程序,用于模拟进程创建和销毁。

程序首先创建一个父进程,并利用fork()函数创建两个子进程。

然后,父进程等待子进程结束后输出一条消息并退出。

接着,我们修改了程序,使用了wait()函数来实现进程调度。

wait()函数可以让父进程等待子进程结束后再继续执行。

我们在程序中使用了两个wait()函数来实现进程的顺序执行。

最后,我们添加了一个信号处理函数,用于处理子进程结束时发送的SIGCHLD信号。

信号处理函数可以在子进程结束时立即执行,不需要等待父进程调度。

2. 内存管理接下来,我们使用C语言编写了一个简单的程序,用于模拟内存分配和回收。

程序首先创建一个指向整型数组的指针,并使用malloc()函数动态分配一块内存。

然后,在内存中写入一些数据,并输出到屏幕上。

最后,使用free()函数释放内存并退出程序。

在编写程序时,我们注意到malloc()和free()函数是操作系统提供的内存管理接口。

malloc()函数可以动态分配一块指定大小的内存,并返回一个指向该内存区域的指针;而free()函数可以释放之前分配的内存。

计算机专业基础综合操作系统(进程管理)模拟试卷1(题后含答案及解析)

计算机专业基础综合操作系统(进程管理)模拟试卷1(题后含答案及解析)

计算机专业基础综合操作系统(进程管理)模拟试卷1(题后含答案及解析)题型有:1. 单项选择题 2. 综合应用题单项选择题1-40小题,每小题2分,共80分。

下列每题给出的四个选项中,只有一个选项是最符合题目要求的。

1.进程处于( )等待状态时,它是处于非阻塞状态的。

A.等待从键盘输入数据B.等待协作进程的一个信号C.等待操作系统分配CPU时间D.等待网络数据进入内存正确答案:C 涉及知识点:操作系统2.下列叙述中,错误的是( )。

A.操作系统是用户与计算机之间的接口B.程序的并发执行,使程序失去了顺序执行时具有的封闭性和可再现性,程序与程序的执行不再一一对应C.进程从一个状态到另一个状态的转换,都是靠使用不同的原语来实现的D.在单CPU系统中,任何时刻处于就绪状态的进程有多个,而且只有处于就绪状态的进程经调度程序选中后才可进入运行状态正确答案:C解析:从用户的角度看,操作系统是用户使用计算机的桥梁,用户通过操作系统的两类接口来达到操纵计算机的目的。

选项A正确。

选项B的叙述也是正确的,因为这正是引入进程概念的原因。

进程从一个状态到另一个状态的转换是一个非常复杂的过程,除了要使用不同的原语外,有时还要借助于硬件触发器才能完成。

例如,UNIX系统中,从系统态到用户态的转换要借助硬件触发器。

因此,选项C错误。

处于就绪状态的进程已经获得了除CPU之外的所有资源,由于只有一个CPU,任何时刻就只能有一个进程获得CPU,而其他的就只能在就绪状态对应的队列上排队等待调度程序的调度。

所以选项D也正确。

知识模块:操作系统3.进程调度是从( )选择一个进程投入运行的。

A.就绪队列B.等待队列C.作业后备队列D.提交队列正确答案:A解析:处于就绪队列的进程是获得了除处理机以外的所有资源处于准备执行的状态。

进程调度就是负责从就绪队列中挑选进程投入运行的。

知识模块:操作系统4.下列叙述中,正确的是( )。

A.分时系统中,时间片越小,响应时间越长B.多道程序的引入,主要是为了提高CPU及其他资源的利用率C.飞机票订票系统是分时系统D.PCB是进程存在的唯一标志,而程序是系统感知进程存在的唯一实体正确答案:B解析:分时系统的响应时间T≈nq,n是用户数目,而q是时间片。

计算机操作系统实验---进程调度

计算机操作系统实验---进程调度

操作系统实验报告--进程调度计科02-8 王长青05年4月17日计算机操作系统实验——进程调度一.实验目的进程调度是处理机管理的核心内容。

通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会和了解优先数调度算法的具体实施办法。

二.程序功能本程序使用VC++编译调试,用于实现进程优先数调度的模拟。

主要包含三个模块:1、主界面:用于显示进程调度的过程。

2、数据录入模块:用于获取进程的初始值,其中有三种获取方式,手动输入方式、随即生成方式和从文件中读去数据的方式。

当用户在主窗口中点击“开始”菜单项时即可打开数据录入对话框,用户通过这三种方式之一均可完成数据的录入。

3、进程控制模块:主要实现创建新的进程,就绪队列的管理,完成队列的管理,进程的调度。

三.实验原理(1)本程序采用优先数调度算法对进程进行调度,每个进程可有三个状态,即:就绪状态,运行状态,完成状态。

并假设初始状态为就绪状态。

这三种状态的转换情况如右图:(2)为了便于处理,程序中的某进程运行时间以时间片为单位计算。

各进程的优先数以及进程需运行的时间片数的初始值均由用户给定(通过数据录入模块完成)。

(3)程序通过设置一个定时器来实现时间片的轮转,时间片的大小是1秒,在定时器消息的响应函数中从用户录入的数据中读取一个创建进程,将其加入到就绪队列中,然后进行调度和执行。

在调度函数中,对于遇到优先数一致的情况,采用FIFO策略解决。

(4)在优先数算法中,进程每执行一次,优先数减3,进程还需要运行的时间数减1。

四.详细设计(1)设计进程控制块PCB结构:struct PCB{ int pid; //进程号int pri; //进程优先数int time; //进程所需运行时间int status; // 进程状态 0就绪,1 执行,-1完成};(2)将进程的各种操作封装在类CProMoni中,该类的定义如下:class CProMoni{public:CProMoni();virtual ~CProMoni();void InsertRQ(PCB* p); //将p所指的进程插入到就绪队列中void InsertFQ(PCB* p); //将p所指的进程插入到完成队列中void ProSchedule(); //进程调度函数void ProRun(); //运行函数void Display(CDC* pDC); //以表格形式输出运行过程bool GetFinishFlag();bool OpenLogFile(); //打开日志文件void CloseLogFile(); //关闭日志文件bool WriteLogToFile(); //向日志文件中写入数据private:PCB *m_pRunning; //指向当前运行的进程CPtrList m_readyList; //就绪队列CPtrList m_finishList; //完成队列bool m_finish; //完成标志CString m_LogFileName; //日志文件名CStdioFile m_LogFile; //日志文件public:int m_clock; //时钟序列};(3)主要成员函数的实现:void CProMoni::InsertRQ(PCB* p){ //将p插入到就绪队列中POSITION pre,pos=m_readyList.GetHeadPosition();PCB *q;while(pos!=NULL){pre=pos;q=(PCB*)m_readyList.GetNext(pos);if(q->pri < p->pri){m_readyList.InsertBefore(pre,p);return;}}if(pos==NULL){m_readyList.AddTail(p);}}void CProMoni::ProSchedule(){//进程调度PCB *p;if(m_pRunning==NULL){if(m_readyList.IsEmpty()){m_finish=true;return;}else{p=(PCB*)m_readyList.RemoveHead();m_pRunning=p;}}else{if(!m_readyList.IsEmpty()){p=(PCB*)m_readyList.GetHead();//m_readyList将头节点与当前PCB的权值比较if(p->pri > m_pRunning->pri ){PCB *q=m_pRunning;m_pRunning=(PCB*)m_readyList.RemoveHead();m_pRunning->status=1;q->status=0;InsertRQ(q);}}}}void CProMoni::ProRun(){//运行进程if(!m_finish){if(m_pRunning==NULL){ AfxMessageBox("当前运行的进程不存在!");return;}m_pRunning->pri-=3;m_pRunning->time-=1;{ m_pRunning->time=0;PCB*p=m_pRunning;p->status=-1;InsertFQ(p);m_pRunning=NULL;}}}(4)试图类的主要成员函数:PCB* CProcessView::CreatePCB(){//创建PCBPCB* p=new PCB;p->pid=n+1;p->pri=m_pris[n];p->time=m_times[n];p->status=0;n++;return p;}#include"pritimedlg.h"void CProcessView::OnStart(){ CPriTimeDlg dlg; //定义数据录入对话框dlg.DoModal();if(dlg.m_ok){ m_proTotal=dlg.m_proNum;for(int i=0;i<m_proTotal;i++){ m_pris[i]=dlg.m_pris[i];m_times[i]=dlg.m_times[i];}m_proMoni.OpenLogFile(); //打开日志文件PCB* p=CreatePCB(); //创建新进程m_proMoni.InsertRQ(p); //将新进程插入到就绪队列中m_proMoni.WriteLogToFile(); //写日志文件m_proMoni.ProSchedule(); //进程调度m_start=true; //设置开始标志Invalidate(); //刷新视图m_killTimer=false;SetTimer(1,1000,NULL);//设置定时器}}void CProcessView::OnTimer(UINT nIDEvent){ m_proMoni.m_clock++;m_proMoni.WriteLogToFile();//写日志m_proMoni.ProRun(); //运行进程if(n<m_proTotal){ PCB *p=CreatePCB();//创建新进程m_proMoni.InsertRQ(p);}m_proMoni.ProSchedule();Invalidate();if(m_proMoni.GetFinishFlag()){//若已完成则删除定时器KillTimer(1);m_killTimer=true;AfxMessageBox("演示完毕");}CScrollView::OnTimer(nIDEvent);}五.运行结果(1)数据录入界面:(2)进程调度过程的结果:六、实验总结通过本实验使我对进程的相关概念及进程的优先数调度算法有了更深的理解,使自己在程序设计及编制方面也有了一定的提高。

操作系统实验之进程管理实验报告

操作系统实验之进程管理实验报告

操作系统实验之进程管理实验报告一、实验目的本次操作系统实验的主要目的是深入理解进程管理的概念和原理,通过实际操作和观察,掌握进程的创建、调度、同步与互斥等关键机制。

二、实验环境本次实验使用的操作系统为 Windows 10,开发工具为 Visual Studio 2019,编程语言为 C++。

三、实验内容1、进程创建使用系统提供的 API 函数创建新的进程。

观察新进程的资源使用情况和运行状态。

2、进程调度编写程序模拟不同的进程调度算法,如先来先服务(FCFS)、短作业优先(SJF)和时间片轮转(RR)。

比较不同调度算法下的平均周转时间、平均等待时间等性能指标。

3、进程同步与互斥利用信号量、互斥锁等机制实现进程之间的同步与互斥。

设计并发程序,解决生产者消费者问题、读写者问题等经典同步问题。

四、实验步骤1、进程创建实验首先,包含所需的头文件,如`<windowsh>`。

然后,定义创建进程的函数,使用`CreateProcess` 函数创建新进程,并获取进程的相关信息,如进程标识符、线程标识符等。

最后,通过查看任务管理器或其他系统工具,观察新创建进程的资源占用情况。

2、进程调度实验设计不同的调度算法函数,如`FCFSSchedule`、`SJFSchedule` 和`RRSchedule`。

在每个调度算法函数中,模拟进程的到达时间、服务时间等参数,并按照相应的算法进行进程调度。

计算每个进程的周转时间和等待时间,并求出平均周转时间和平均等待时间。

3、进程同步与互斥实验定义信号量或互斥锁变量。

在生产者消费者问题中,生产者在生产产品时获取互斥锁,生产完成后释放互斥锁并通知消费者;消费者在消费产品时获取互斥锁,消费完成后释放互斥锁。

在读写者问题中,读者在读取数据时获取共享锁,读完后释放共享锁;写者在写入数据时获取独占锁,写入完成后释放独占锁。

五、实验结果与分析1、进程创建实验结果成功创建新的进程,并能够获取到进程的相关信息。

操作系统实验(模拟进程管理)

操作系统实验(模拟进程管理)

操作系统实验————(1)模拟进程管理专业:信息管理与信息系统班级:信管082姓名:温静实验一进程管理1.目的和要求通过实验理解进程的概念,进程的组成(PCB结构),进程的并发执行和操作系统进行进程管理的相关原语(主要是进程的创建、执行、撤消)。

2.实验内容用C语言编程模拟进程管理,至少要有:创建新的进程;查看运行进程;换出某个进程;杀死运行进程以及进程之间通信等功能。

3.主体程序#include <conio.h>#include <stdio.h>#include <stdlib.h>struct PCB_type{ int pid;int priority;int cputime;int state;int shumu=0,pid_l;struct PCB_type neicun[20];struct PCB_type hc[10];int max=0;int number=0;void create();void run();void huanchu();void kill();/* 创建新进程*/void create(){if(shumu>=20){printf("\n内存已满,请先结束或换出进程\n");}else{shumu++;printf("\n请输入新进程的程序名\n");scanf("%d",&neicun[shumu-1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu-1].priority);printf("\n请输入新进程的运行时间\n");scanf("%d",&neicun[shumu-1].cputime);printf("\n创建进程时令其状态为就绪\n");neicun[shumu-1].state=2;}printf("\n创建进程成功!\n");}/* 查看当前运行进程*/void run(){int max=0;for(int i=0;i<shumu;i++){if((neicun[i].state==1)&&(neicun[i].priority>=neicun[max].priority)) max=i;}neicun[max].state=3;printf("当前运行进程程序名:\n%d",neicun[max].pid);printf("\n该进程的优先级:\n%d",neicun[max].priority);printf("\n该进程的运行时间:\n%d",neicun[max].cputime);printf("\n该进程的状态:\n%d",neicun[max].state);}/* 换出*/void huanchu(){int k;printf("请输入要换出程序的程序名:");scanf("%d",&k);for(int j=0;j<shumu;j++){if(neicun[j].state==1){hc[number].pid=neicun[j].pid;hc[number].state=neicun[j].state;hc[number].priority=neicun[j].priority;hc[number].cputime=neicun[j].cputime;number++;neicun[j].pid=0;neicun[j].state=0;neicun[j].priority=0;neicun[j].cputime=0;pid_1++;}else printf("进程%d无法换出的pid:%d\n",j.neicun[j].pid);if(number!=0)for(int i=0;i<number;i++){printf("当前运行进程程序名:\n%d",hc[i].pid);printf("\n该进程的优先级:\n%d",hc[i].priority);printf("\n该进程的运行时间:\n%d",hc[i].cputime);printf("\n该进程的状态:\n%d",hc[i].state);}}PCB_type temp=neicun[0];for(k=0;k<=shumu;k++){if(neicun[k].priority>temp.priority)tmpe=neicun[k];}neicun[k].state=1;}/* 杀死进程*/void kill(){neicun[max].pid=0;neicun[max].priority=0;neicun[max].cputime=0;neicun[max].state=0;if(max==(shumu-1))shumu--;else{for(int j=max+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}max=0;run();}/* int k=0;printf("请输入要杀死程序的进程名:");scanf("%d",&k);if(neicun[k].state=1)neicun[k].state=2;neicun[k].cputime=0;neicun[k].pid=0;neicun[k].priority=0;neicun[k].state=0;if(k==(shumu-1))shumu--;else{for(int j=k+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}printf("进程%d已被杀死!,k");}*/int main(){int n,a;n=1;while(n==1){system("cls");printf("\n**********************************************");printf("\n* 进程演示系统*");printf("\n**********************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.退出系统");printf("\n**********************************************");printf("\n请选择(1~5):");scanf("%d",&a);switch(a){ case 1:create( );printf("\npress anykey to go on~");getch();break;case 2 :run();printf("\npress anykey to go on~");getch();break;case 3 :huanchu();printf("\npress anykey to go on~");getch();break;case 4 :kill();printf("\npress anykey to go on~");getch();break;case 5 :exit(0);default:n=0;break;}}}5.感想与心得体会做了两周的实验,问了很多同学,可程序还是有很多问题。

模拟进程创建实验报告(3篇)

模拟进程创建实验报告(3篇)

第1篇一、实验目的1. 理解进程的概念和进程创建的基本原理。

2. 掌握使用C语言模拟进程创建的方法。

3. 熟悉进程的属性和进程之间的通信机制。

4. 分析实验结果,加深对进程管理的理解。

二、实验环境1. 操作系统:Windows 102. 编程语言:C语言3. 开发环境:Visual Studio 2019三、实验原理进程是计算机中程序执行的基本单位,是操作系统进行资源分配和调度的一个独立单位。

进程创建是操作系统的一个重要功能,它负责为进程分配必要的资源,并建立进程控制块(PCB)。

在模拟进程创建实验中,我们将使用C语言编写程序,模拟进程的创建、运行和销毁过程。

通过模拟进程的创建,我们可以了解进程的基本属性,如进程ID、进程状态、父进程ID等。

四、实验步骤1. 定义进程结构体,包含进程的基本属性,如进程ID、进程状态、父进程ID等。

```ctypedef struct {int pid; // 进程IDint state; // 进程状态int parent_pid; // 父进程ID// 其他属性} Process;```2. 编写进程创建函数,用于创建新进程。

```cProcess create_process(int parent_pid) {Process new_process;new_process.pid = ...; // 分配进程IDnew_process.state = ...; // 设置进程状态 new_process.parent_pid = parent_pid;// 设置其他属性return new_process;}```3. 编写进程运行函数,用于模拟进程的运行过程。

```cvoid run_process(Process p) {// 模拟进程运行过程// ...}```4. 编写进程销毁函数,用于销毁进程。

```cvoid destroy_process(Process p) {// 销毁进程资源// ...}```5. 编写主函数,模拟进程创建、运行和销毁过程。

操作系统原理实验

操作系统原理实验

操作系统原理实验操作系统是计算机系统中最核心的部分之一,它负责管理和控制计算机的硬件和软件资源,为用户提供一个良好的工作环境。

操作系统原理实验是计算机相关专业的学生必修课程之一,通过实验学习,可以更深入地理解操作系统的原理和工作机制,提高对操作系统的理解和应用能力。

实验一,进程管理。

进程是操作系统中最基本的概念之一,它是程序执行的基本单位。

在进程管理实验中,我们可以学习到进程的创建、调度、同步和通信等内容。

通过编写程序模拟进程的创建和调度过程,可以更直观地理解操作系统是如何管理进程的。

实验二,内存管理。

内存管理是操作系统中的重要内容之一,它负责管理计算机的内存资源,包括内存的分配与回收、内存的保护和共享等。

在内存管理实验中,我们可以学习到内存分配算法、地址转换技术以及虚拟内存的实现原理。

通过编写程序模拟内存分配和回收的过程,可以更好地理解操作系统是如何管理内存的。

实验三,文件系统。

文件系统是操作系统中负责管理存储设备上的文件和目录的部分,它提供了对文件的读写和管理功能。

在文件系统实验中,我们可以学习到文件的组织结构、文件的存储管理和文件的访问控制等内容。

通过编写程序模拟文件的创建、读写和删除过程,可以更深入地理解操作系统是如何管理文件系统的。

实验四,设备管理。

设备管理是操作系统中负责管理计算机硬件设备的部分,它包括对设备的初始化、分配和释放等功能。

在设备管理实验中,我们可以学习到设备的管理方法、设备的中断处理和设备的驱动程序设计等内容。

通过编写程序模拟设备的初始化和中断处理过程,可以更好地理解操作系统是如何管理设备的。

总结。

通过操作系统原理实验的学习,我们可以更深入地理解操作系统的原理和工作机制,提高对操作系统的理解和应用能力。

同时,实验还可以培养我们的动手能力和解决问题的能力,为今后从事计算机相关工作打下坚实的基础。

希望大家能够认真对待操作系统原理实验,取得更好的学习成绩,为将来的发展打下坚实的基础。

操作系统进程调度模拟程序实验报告

操作系统进程调度模拟程序实验报告

操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序,以加深对进程调度算法的理解。

二、实验内容1. 实现进程相关的数据结构:进程PCB(Process Control Block)。

2.实现进程的创建、撤销以及调度等操作函数。

3. 实现常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)、轮转调度(RR)、优先级调度(Priority)。

4.编写测试程序,验证实现的进程调度算法在不同场景下的表现。

三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构,用于存储和管理进程相关的信息,包括进程状态(就绪、运行、阻塞)、优先级、执行时间等。

2.进程的创建、撤销及调度函数的实现(1)进程创建函数:实现进程的创建,包括为其分配空间、初始化进程PCB等。

可以根据实际需求,设定进程的优先级、执行时间等属性。

(2)进程撤销函数:实现进程的撤销,包括释放其占用的资源、回收其使用的空间等。

(3)进程调度函数:根据不同的调度算法,实现进程的调度。

可以通过设置时间片大小、优先级设定等方式,实现不同调度算法的效果。

3.进程调度算法的设计与实现(1)先来先服务(FCFS)调度算法:按照进程到达的先后顺序,依次进行调度。

(2)最短作业优先(SJF)调度算法:根据进程的执行时间,选择执行时间最短的进程进行调度。

(3)轮转调度(RR)算法:按照时间片的大小进行调度,每个进程在一个时间片内执行,超过时间片后,暂停并进入等待队列,让其他进程执行。

(4)优先级调度(Priority)算法:根据进程的优先级,选择优先级最高的进程进行调度。

4.测试程序编写测试程序,模拟不同的进程到达顺序、执行时间和优先级等场景,验证不同调度算法的表现。

四、实验结果与分析通过测试程序的运行结果,观察不同调度算法的特点和效果。

可以得出以下结论:1.FCFS算法适用于进程到达时间差异较大的场景,保证了先到先服务。

操作系统的进程管理与调度

操作系统的进程管理与调度

操作系统的进程管理与调度操作系统是计算机系统中一种非常关键的软件,它负责管理计算机的资源,并为用户提供一个良好的工作环境。

在操作系统中,进程管理与调度是其中一个重要的功能模块。

本文将对操作系统的进程管理与调度进行深入探讨。

一、进程管理进程是计算机中正在运行的程序的实例。

进程管理是指操作系统对进程进行创建、调度、挂起、唤醒、终止等管理操作。

主要包括进程控制块(PCB)的创建和维护、进程状态的转换和切换、进程同步与互斥等内容。

1. 进程控制块(PCB)进程控制块是操作系统管理进程的一种数据结构,用于保存进程的相关信息。

它包括进程的标识符、状态、优先级、程序计数器、寄存器信息、内存分配情况等。

系统通过操作PCB来管理和控制进程的运行。

2. 进程状态转换进程可以处于运行、就绪、阻塞等不同的状态。

当一个进程正在执行时,如果遇到等待某个事件发生的情况,比如用户输入、磁盘读写完成等,它将会被阻塞。

当等待的事件发生后,进程将会从阻塞状态切换回就绪状态,等待CPU调度来执行。

3. 进程同步与互斥为了保证多个进程之间的数据访问安全和正确性,操作系统需要提供进程间的同步与互斥机制。

常用的机制包括信号量、互斥锁、条件变量等。

二、进程调度进程调度是操作系统中的一个核心功能,它决定着进程以何种顺序进入运行态,从而合理利用计算机的资源,提高系统的吞吐量和响应速度。

常见的调度算法有先来先服务(FCFS)、短作业优先(SJF)、轮转调度(RR)和最高响应比优先调度(HRRN)等。

1. 先来先服务调度(FCFS)FCFS调度算法是按照进程到达的先后顺序来进行调度的。

优点是简单直观,公平性好。

但是当一个长作业处于运行状态时,其他短作业需要等待较长时间,容易造成短作业的响应时间较长,不适用于实时环境。

2. 短作业优先调度(SJF)SJF调度算法会优先选择估计运行时间最短的进程进行调度。

它可以最大程度地减少平均等待时间和平均周转时间,但存在一定的不可预测性。

全国自考操作系统(进程管理)模拟试卷2.doc

全国自考操作系统(进程管理)模拟试卷2.doc
(A)只有一个
(B)可以有多个
(C)不能被挂起
(D)必须在执行完后才能被撤下
5用户编写的C程序中的自动变量位于进程映像的_______部分。
(A)数据段
(Bபைடு நூலகம்用户栈
(C)正文段
(D)堆段
6在单CPU的操作系统中,如当前共有4个进程,其中1个进程在核心态下执行,至少有_______个进程处于核心态。
(A)1
(C)后者可并发执行,前者则不行
(D)前者是批处理的,后者是分时的
3某一进程从阻塞状态进入就绪状态可能原因之一是_______。
(A)现运行进程运行结束
(B)现运行进程执行了semWait操作
(C)现运行进程执行了semSignal操作
(D)现运行进程时间片用完
4在UNIX的单处理机系统中,处于SRUN状态的进程_______。
(B)2
(C)3
(D)4
7 UNIX的切换调度程序swtch的第一部分和第三部分涉及进程现场的保护和恢复,在该程序中保护和恢复的一般是_______的现场。
(A)系统进程
(B)用户进程
(C)同一个进程
(D)不同的进程
8在UNIX系统中,核心发现了可能更适合占用处理机的进程,设置了强迫调度标志_______。
(A)runout
(B)runin
(C)runrun
(D)flag
9父进程刚执行了系统调用fork创建一个子进程后,这个子进程的初始状态为_______。
(A)创建态
(B)睡眠态
(C)就绪态
(D)等待态
二、填空题
10作业控制方式有_______和_______。
11在图3—1中,①表示_______状态。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
case 4:os.SetStrategy(3);break;
default:
cout<<"\n你的选择不正确,将以缺省值运行"<<endl;
os.SetStrategy(0);break;
}
cout<<"\n请输入你想建立的进程数量(最大20):";
scanf("%d",&max);
if (max<1||max>20)
List(char* nodetype="就绪");//构造函数,初始化
virtual ~List();
};
#endif // !defined(AFX_LIST_H__6D78FEEC_384C_415E_97A1_83FD6734BF4C__INCLUDED_)
// Os.h: interface for the Os class.
四、实验过程:
1、设计PCB和链表
A、PCB采用结构体设计,用于描述进程运行所需的全部信息,作为OS对并发执行的进程进行控制和管理的根据,其贯穿进程的整个生命周期,是进程存在的唯一标志。其结构图如下:
id
name
status
next
priority
IOdevice
IOreq
blockfor
timereq
PCB4
PCB5
PCB6
PCB7
PCB8
PCB9
...
4
3
0
8
7
9
0
1
链表类的数据及其所支持的操作如下图:
各操作函数功能说明如下:
Status AppendPCB(PCB *datap);
将指定PCB加入链表。
PCB *DeletePCB(int pid);删除指定的PCB结点
void DisplayList();显示整个链表
Status isEmpty();//判断链表是否为空
Status GetFirstPCB(PCB* &pcb);//取第一个结点
void SetStatus(char *s);//设置状态标识
void SetListHead(PCB*pcb);//设置头指针
void SetListTail(PCB*pcb);//设置尾指针
time_cpu
address
Id:进程内部标识符。用于标识一个进程name:进程外部标识符。也用于标识一个进程。
Status:进程当前状态。作为进程调度的参考。Priority:进程优先级。作为进程调度的参考。
Next:状态指针。用于指向同状态的下一个PCB
Iodevice:外设清单。作为进程调度的参考。Blockfor:阻塞原因,作为唤醒进程的标志。
PCBstatus status;//进程当前状态;
struct PCB *next;//指向同状态的下一个PCB
int priority;//进程优先级;
int IOdevice;//外设清单
int IOreq;//进程还需要的外部设备;
int blockfor;//阻塞原因;
int timereq;//进程要求的执行时间
strcpy(name,"Process");
}
cout<<"\n按任意键运行........"<<endl;
getch();
while(i<max)
{
i++;
_itoa(i,s,10);//系统函数,将数转换成10进制
strcpy(temp,name);
strcat(temp,s);
os.CreateProcess(temp);
void DisplayPCB(PCB *pcb);
显示PCB中的详细信息
PCB* FindPCB(int pid,PCB* &pre);
查找指定的结点
PCB* FindPCB(int pnum);
查找链表中的第pnum个结点
char* GetListStatus();
取得当前链表PCB结点的状态
int GetNodeNum();取得链表的结点数
void displayMenu()
{
cout<<"操作系统进程管理与调度的模拟"<<endl;
cout<<"1.先来先服务"<<endl;
cout<<"2.最短作业优先"<<endl;
cout<<"3.优先级算法"<<endl;
cout<<"4.时间片轮转算法"<<endl;
cout<<"0.退出"<<endl;
public:
Status AppendPCB(PCB *datap);//将指定PCB加入链表
PCB *DeletePCB(int pid);//删除指定的PCB结点
void DisplayList();//显示整个链表
void DisplayPCB(PCB *pcb);//显示PCB中的详细信息
//
#include "stdafx.h"
#include "List.h"
#include "Os.h"
#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <process.H>
using namespace std;
void SetListTail(PCB*pcb);设置尾指针
List(char* nodetype="就绪");构造函数,初始化
virtual ~List();虚函数
链表的构造函数:
void List::SetNodeNum(int k)设置链表结点数
{NodeNum=k;return;}
void List::SetStatus(char *s);设置状态标识
PCB* FindPCB(int pid,PCB* &pre);//查找指定的结点
PCB* FindPCB(int pnum);//查找链表中的第pnum个结点
char* GetListStatus();//取得当前链表PCB结点的状态
int GetNodeNum();//取得链表的结点数
void SetNodeNum(int k);//设置链表结点数
#pragma once
#endif // _MSC_VER > 1000
#include "ConstVar.h"
#include <iostream>
using namespace std;
class Os;
typedef struct PCB
{
int id;//进程标识符;
char *name;//进程名字;
cout<<"请输入您的选择:1为缺省值---";
}
int main(int argc, char* argv[])
{
Os os;
int choice,max,i=0;
char name[80]="Process";
char s[10],temp[20];
while (1)
{
system("cls");
displayMenu();
scanf("%d",&choice);
switch(choice)
{
case 0:exit(0);break;
case 1:os.SetStrategy(0);break;
case 2:os.SetStrategy(1);break;
case 3:os.SetStrategy(2);break;
void SetNodeNum(int k);设置链表结点数
Status isEmpty();判断链表是否为空
Status GetFirstPCB(PCB* &pcb);取第一个结点
void SetStatus(char *s);设置状态标识
void SetListHead(PCB*pcb);设置头指针
#if !defined(AFX_LIST_H__6D78FEEC_384C_415E_97A1_83FD6734BF4C__INCLUDED_)
#define AFX_LIST_H__6D78FEEC_384C_415E_97A1_83FD6734BF4C__INCLUDED_
#if _MSC_VER > 1000
//cout<<temp<<endl;
}
os.scheduler();
_getch();
if(!cin) break;
}
/*return 0;*/
}
// List.h: interface for the List class.
//
//////////////////////////////////////////////////////////////////////
int time_cpu;//已经执行的时间;
void (*fuction)(Os *);//模拟进程要执行的代码的地址
相关文档
最新文档