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

合集下载

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统实验实验报告

操作系统实验实验报告

操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件,它管理着计算机的硬件资源和软件资源,为用户提供了一个方便、高效、稳定的工作环境。

本次操作系统实验的目的在于通过实际操作和实践,深入理解操作系统的基本原理和核心概念,掌握操作系统的基本功能和操作方法,提高对操作系统的认识和应用能力。

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

实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。

三、实验内容(一)进程管理实验1、进程创建与终止通过编程实现创建新的进程,并在完成任务后终止进程。

在实验中,我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。

通过观察进程的创建和终止过程,深入理解了进程的生命周期和状态转换。

2、进程同步与互斥为了实现进程之间的同步与互斥,我们使用了信号量、互斥量等同步对象。

通过编写多线程程序,模拟了多个进程对共享资源的访问,实现了对共享资源的互斥访问和同步操作。

在实验中,我们深刻体会到了进程同步与互斥的重要性,以及不正确的同步操作可能导致的死锁等问题。

(二)内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。

通过实验,了解了内存分配的不同方式(如堆分配、栈分配等)以及内存释放的时机和方法,掌握了内存管理的基本原理和操作技巧。

2、内存分页与分段通过编程模拟内存的分页和分段管理机制,了解了内存分页和分段的基本原理和实现方法。

在实验中,我们实现了简单的内存分页和分段算法,对内存的地址转换和页面置换等过程有了更深入的理解。

(三)文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。

(完整word版)操作系统实验报告.实验一 WINDOWS进程初识

(完整word版)操作系统实验报告.实验一 WINDOWS进程初识

操作系统教程实验指导书实验一WINDOWS进程初识1、实验目的(1)学会使用VC编写基本的Win32 Consol Application(控制台应用程序)。

(2)掌握WINDOWS API的使用方法。

(3)编写测试程序,理解用户态运行和核心态运行。

2、实验内容和步骤(1)编写基本的Win32 Consol Application步骤1:登录进入Windows,启动VC++ 6.0。

步骤2:在“FILE”菜单中单击“NEW”子菜单,在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名,在“Location”处输入工程目录。

创建一个新的控制台应用程序工程。

步骤3:在“FILE”菜单中单击“NEW”子菜单,在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。

步骤4:将清单1-1所示的程序清单复制到新创建的C/C++源程序中。

编译成可执行文件。

步骤5:在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令,进入Windows “命令提示符”窗口,然后进入工程目录中的debug子目录,执行编译好的可执行程序:E:\课程\os课\os实验\程序\os11\debug>hello.exe运行结果 (如果运行不成功,则可能的原因是什么?) :答:运行成功,结果:(2)计算进程在核心态运行和用户态运行的时间步骤1:按照(1)中的步骤创建一个新的“Win32 Consol Application”工程,然后将清单1-2中的程序拷贝过来,编译成可执行文件。

步骤2:在创建一个新的“Win32 Consol Application”工程,程序的参考程序如清单1-3所示,编译成可执行文件并执行。

步骤3:在“命令提示符”窗口中运行步骤1中生成的可执行文件,测试步骤2中可执行文件在核心态运行和用户态运行的时间。

操作系统实验报告6

操作系统实验报告6

操作系统实验报告6一、实验目的本次操作系统实验的主要目的是深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关技术,通过实际操作和观察,增强对操作系统工作原理的理解,并提高解决实际问题的能力。

二、实验环境本次实验使用的操作系统为 Windows 10,实验工具包括 Visual Studio 2019 等。

三、实验内容(一)进程管理实验1、创建多个进程,并观察它们的运行状态和资源占用情况。

通过编写简单的C++程序,使用Windows API 函数创建多个进程。

在程序中,设置不同的进程优先级和执行时间,观察操作系统如何调度这些进程,以及它们对 CPU 使用率和内存的影响。

2、进程间通信实现了进程间的管道通信和消息传递。

通过创建管道,让两个进程能够相互交换数据。

同时,还使用了 Windows 的消息机制,使进程之间能够发送和接收特定的消息。

(二)内存管理实验1、内存分配与释放使用 C++的动态内存分配函数(如`malloc` 和`free`),在程序运行时动态申请和释放内存。

观察内存使用情况,了解内存碎片的产生和处理。

2、虚拟内存管理研究了 Windows 操作系统的虚拟内存机制,通过查看系统的性能监视器,观察虚拟内存的使用情况,包括页面文件的大小和读写次数。

(三)文件系统实验1、文件操作进行了文件的创建、读取、写入、删除等基本操作。

通过编写程序,对不同类型的文件(如文本文件、二进制文件)进行处理,了解文件系统的工作原理。

2、目录操作实现了目录的创建、删除、遍历等功能。

了解了目录结构在文件系统中的组织方式和管理方法。

四、实验步骤(一)进程管理实验步骤1、打开 Visual Studio 2019,创建一个新的 C++控制台项目。

2、在项目中编写代码,使用`CreateProcess` 函数创建多个进程,并设置它们的优先级和执行时间。

3、编译并运行程序,通过任务管理器观察进程的运行状态和资源占用情况。

电大操作系统实验报告3_ 进程管理实验

电大操作系统实验报告3_ 进程管理实验

电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一,本次实验的目的是通过实际操作和观察,深入理解进程的概念、状态转换、进程调度以及进程间的通信机制,掌握操作系统中进程管理的基本原理和方法,提高对操作系统的整体认识和实践能力。

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

三、实验内容及步骤(一)进程的创建与终止1、编写一个 C 程序,使用系统调用创建一个子进程。

2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。

3、子进程执行一段简单的计算任务,父进程等待子进程结束后输出结束信息。

以下是实现上述功能的 C 程序代码:```cinclude <stdioh>include <stdlibh>include <unistdh>int main(){pid_t pid;pid = fork();if (pid < 0) {printf("创建子进程失败\n");return 1;} else if (pid == 0) {printf("子进程:我的进程 ID 是%d,父进程 ID 是%d\n",getpid(), getppid());int result = 2 + 3;printf("子进程计算结果:2 + 3 =%d\n", result);exit(0);} else {printf("父进程:我的进程 ID 是%d,子进程 ID 是%d\n",getpid(), pid);wait(NULL);printf("子进程已结束\n");}return 0;}```编译并运行上述程序,可以观察到父进程和子进程的输出信息,验证了进程的创建和终止过程。

(二)进程的状态转换1、编写一个 C 程序,创建一个子进程,子进程进入睡眠状态一段时间,然后被唤醒并输出状态转换信息。

进程管理实验报告_共10篇 .doc

进程管理实验报告_共10篇 .doc

★进程管理实验报告_共10篇范文一:_进程管理实验报告进程管理实验报告一、进程与线程1.实验目的:1.通过本实验学习Linux中创建进程的方法。

2.学习系统调用fork的使用方法。

3.学习系统调用exec族调用的使用方法。

2.实验准备1.进程的创建创建一个进程的系统调用很简单,只要调用fork函数就可以了。

#includepid_tfork();当一个进程调用了fork以后,系统会创建一个子进程,这个子进程和父进程是不同的地方只有它的进程ID和父进程ID,其他的都一样,就像父进程克隆(clone)自己一样,当然创建两个一模一样的进程是没有意义的,为了区分父进程和子进程,我们必须跟踪fork调用返回值。

当fork调用失败的时候(内存不足或者是用户的最大进程数已到)fork返回—1,否则fork的返回值有重要的作用。

对于父进程fork返回子进程ID,而对于fork 子进程返回0,我们就是根据这个返回值来区分父子进程的。

2.关于fork的说明使用该函数时,该函数被调用一次,但返回两次,两次返回的区别是子进程的返回值是0,而父进程的返回值则是新子进程的进程ID。

将子进程ID返回给父进程的理由是:因为一个进程的子进程可以多于一个,所以没有一个函数可以是一个子进程获得其所有子进程的进程ID。

而fork函数使子进程得到的返回值是0的理由是:一个子进程只会有一个父进程,所以子进程总是可以调用函数getpid获得其父进程的进程ID。

3.系统调用exec族调用的说明父进程创建子进程后,子进程一般要执行不同的程序。

为了调用系统程序,我们可以使用系统调用exec族调用。

Exec族调用有以下五个函数:intexecl(constchar*path,constchar*arg,?);intexeclp(constchar*file,constchar*arg,?);intexecle(constchar*path,constchar*arg,?);intexecv(constchar*path,constchar*argv[]);intexecvp(constchar*file,constchar*argv[]);exec族调用可以执行给定程序。

进程管理实验报告分析(3篇)

进程管理实验报告分析(3篇)

第1篇一、实验背景进程管理是操作系统中的一个重要组成部分,它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。

为了加深对进程管理的理解,我们进行了一系列实验,以下是对实验的分析和总结。

二、实验目的1. 加深对进程概念的理解,明确进程和程序的区别。

2. 进一步认识并发执行的实质。

3. 分析进程争用资源的现象,学习解决进程互斥的方法。

4. 了解Linux系统中进程通信的基本原理。

三、实验内容1. 使用系统调用fork()创建两个子进程,父进程和子进程分别显示不同的字符。

2. 修改程序,使每个进程循环显示一句话。

3. 使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号,实现进程的终止。

4. 分析利用软中断通信实现进程同步的机理。

四、实验结果与分析1. 实验一:父进程和子进程分别显示不同的字符在实验一中,我们使用fork()创建了一个父进程和两个子进程。

在父进程中,我们打印了字符'a',而在两个子进程中,我们分别打印了字符'b'和字符'c'。

实验结果显示,父进程和子进程的打印顺序是不确定的,这是因为进程的并发执行。

2. 实验二:每个进程循环显示一句话在实验二中,我们修改了程序,使每个进程循环显示一句话。

实验结果显示,父进程和子进程的打印顺序仍然是随机的。

这是因为并发执行的进程可能会同时占用CPU,导致打印顺序的不确定性。

3. 实验三:使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号在实验三中,我们使用signal()捕捉键盘中断信号(按c键),然后通过kill()向两个子进程发送信号,实现进程的终止。

实验结果显示,当按下c键时,两个子进程被终止,而父进程继续执行。

这表明signal()和kill()在进程控制方面具有重要作用。

4. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。

进程的管理实验报告结论

进程的管理实验报告结论

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一进程管理一、目的进程调度是处理机管理的核心内容。

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

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

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

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

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

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

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

随机产生n进程P i(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为时间片大小(毫秒)//对进程进行初始化,建立就绪数组、阻塞数组。

public void input()//对进程进行初始化,建立就绪队列、阻塞队列{m = int.Parse(textBox4.Text);n = int.Parse(textBox5.Text);a = int.Parse(textBox6.Text);b = int.Parse(textBox7.Text);c = int.Parse(textBox8.Text);a1 = a;b1 = b;c1 = c;r = m - n;time1Inteval = int.Parse(textBox9.Text);timer1.Interval = time1Inteval;for (i = 1; i <= n; i++){pcb jincheng = new pcb();jincheng.id = i;jincheng.ra = (random.Next(a) + 1);jincheng.rb = (random.Next(b) + 1);jincheng.rc = (random.Next(c) + 1);jincheng.ntime = (random.Next(1, 5));jincheng.rtime = 0;listBox1.Items.Add("产生进程ID:" + jincheng.id);listBox1.Items.Add("所需A资源数目:" + jincheng.ra);listBox1.Items.Add("所需B资源数目:" + jincheng.rb);listBox1.Items.Add("所需C资源数目:" + jincheng.rc);listBox1.Items.Add("所需时间片数:" + jincheng.ntime);if ((a - jincheng.ra) >= 0 && (b - jincheng.rb) >= 0 && (c - jincheng.rc) >= 0){a = a - jincheng.ra;b = b - jincheng.rb;c = c - jincheng.rc;jincheng.state = 'W';hready.Add(jincheng);//加入就绪队列}else{jincheng.state = 'B';hblock.Add(jincheng);//加入阻塞队列}listBox1.Items.Add("当前进程状态:" + jincheng.state);}}//从数组起始地址开始输出该数组的内容public void disp(ArrayList list){ArrayList list1 = new ArrayList();list1 = list;if (list1.Count > 0){for (int j = 0; j < list1.Count; j++){pcb p = (pcb)list1[j];listBox1.Items.Add(" " + p.id.ToString() + " " + p.state.ToString() + " " + p.ra.ToString() + " " + p.rb.ToString() + " " + p.rc.ToString()+" " + p.ntime.ToString() + " " + p.rtime.ToString() + " \r\n");}}else{listBox1.Items.Add("\r\n\t 该队列中没有进程!\r\n");}}//输出就绪数组和阻塞数组的信息public void outputall(){listBox1.Items.Add("\r\n=======CPU运行了:" + h.ToString() + "次=======\r\n");listBox1.Items.Add("*********当前就绪队列的信息!*********");listBox1.Items.Add("进程ID 进程状态A资源数B资源数C资源数所需时间片已运行时间片");disp(hready);listBox1.Items.Add("*********当前就阻塞列的信息!*********");listBox1.Items.Add("进程ID 进程状态A资源数B资源数C资源所需时间片已运行时间片");disp(hblock);}//运行就绪数组的头进程,运行一个时间片,轮转一个时间片,时间片轮转调度算法public void running(){ArrayList hready1 = new ArrayList();hready1 = hready;pcb p1 = new pcb();p1=(pcb)hready1[0];p1.state='R';p1.rtime= p1.rtime + 1;h=h+1;listBox1.Items.Add("\r\n~~~~~~~当前正在运行进程ID是:" +p1.id + "~~~~~~~~\r\n");listBox1.Items.Add("\r\n进程ID 进程状态A资源数B资源数C资源数所需时间片已运行时间片\r\n");listBox1.Items.Add(p1.id + " " +p1.state+ " " + p1.ra + " " + p1.rb + " " + p1.rc + " " + p1.ntime + " " + p1.rtime);if (p1.ntime==p1.rtime){listBox1.Items.Add(p1.id.ToString()+"的进程已经完成!\r\n");a = a + p1.ra;b = b + p1.rb;c = c + p1.rc;hready.RemoveAt(0);}else{p1.state='W';hready1.Add(p1);hready.RemoveAt(0);}}//检测当前资源数目是否满足阻塞数组里进程的需求public void testblock(){ArrayList hblock1 = new ArrayList();hblock1 = hblock;for (int m = 0; m < hblock1.Count; m++){pcb p1 = new pcb();p1 = (pcb)hblock1[m];if ((a - p1.ra >= 0) && (b - p1.rb >= 0) && (c - p1.rc >= 0)){p1.state='W';hready.Add(p1);a = a - p1.ra;b = b - p1.rb;c = c - p1.rc;listBox1.Items.Add("ID号为:"+p1.id + "的进程由阻塞队列转入就绪队列~~\r\n");hblock.RemoveAt(m);m--;}}}//检测是否有新的进程产生,随机产生新进程public void testnew(){int t;if (r>0)//r为随机产生的进程数目{t = random.Next(9) + 1;if (t <= 7){listBox1.Items.Add("\r\n有新的进程申请加入:~~");pcb jincheng = new pcb();jincheng.id = i++;jincheng.ra = (random.Next(a) + 1);jincheng.rb = (random.Next(b) + 1);jincheng.rc = (random.Next(c) + 1);jincheng.ntime = (random.Next(1, 5));jincheng.rtime = 0;listBox1.Items.Add("产生进程ID:" + jincheng.id);listBox1.Items.Add("所需A资源数目:" + jincheng.ra);listBox1.Items.Add("所需B资源数目:" + jincheng.rb);listBox1.Items.Add("所需C资源数目:" + jincheng.rc);listBox1.Items.Add("所需时间片数:" + jincheng.ntime);if ((a - jincheng.ra) >= 0 && (b - jincheng.rb) >= 0 && (c - jincheng.rc) >= 0){a = a - jincheng.ra;b = b - jincheng.rb;c = c - jincheng.rc;jincheng.state = 'W';listBox1.Items.Add("进程状态为:" + jincheng.state);hready.Add(jincheng);//加入就绪队列listBox1.Items.Add("资源满足新进程请求,该进程进入就绪队列~~\r\n");}else{jincheng.state = 'B';hblock.Add(jincheng);//加入阻塞队列listBox1.Items.Add("进程状态为:" + jincheng.state);listBox1.Items.Add("资源不满足新进程请求,该进程进入阻塞队列~~\r\n");}}}r = r - 1;}//系统三类资源变化情况的显示public void rescore()//系统三类资源变化情况的显示{if (a > a1) { textBox1.Text = a1.ToString(); }if (a < 0) { textBox1.Text = "0"; }if (a >= 0 && a < a1) { textBox1.Text = a.ToString(); }if (b > b1) { textBox2.Text = b1.ToString(); }if (b < 0) { textBox2.Text = "0"; }if (b >= 0 && b <= b1) { textBox2.Text = b.ToString(); }if (c > c1) { textBox3.Text = c1.ToString(); }if (c < 0) { textBox3.Text = "0"; }if (c >= 0 && c <= c1) { textBox3.Text = c.ToString(); }}//时间片轮转调度算法(先来先服务FCFS算法)public void runFcfs(){if (hready.Count>0){outputall();running();testblock();testnew();rescore();}else{timer1.Enabled = false;textBox1.Text = a1.ToString();textBox2.Text = b1.ToString();textBox3.Text = c1.ToString();listBox1.Items.Add("\r\n<<<<<<<<所有进程都已经运行结束!>>>>>>>~\r\n");}//计时器触发时间片轮转调度算法private void timer1_Tick(object sender, EventArgs e){runFcfs();}//开始模拟按钮单击执行函数private void button1_Click(object sender, EventArgs e) {runmain();button1.Enabled = false;textBox1.Enabled = false;textBox2.Enabled = false;textBox3.Enabled = false;textBox4.Enabled = false;textBox5.Enabled = false;textBox6.Enabled = false;textBox7.Enabled = false;textBox8.Enabled = false;textBox9.Enabled = false;}//清除屏幕按钮单击执行函数private void button2_Click(object sender, EventArgs e) {textBox1.Text = "";textBox2.Text = "";textBox3.Text = "";textBox4.Text = "";textBox5.Text = "";textBox6.Text = "";textBox7.Text = "";textBox8.Text = "";textBox9.Text = "";listBox1.Items.Clear();textBox4.Enabled = true;textBox5.Enabled = true;textBox6.Enabled = true;textBox7.Enabled = true;textBox8.Enabled = true;textBox9.Enabled = true;button1.Enabled = true;}//运行的主函数public void runmain(){input();imer1.Enabled = true;}3、运行界面和运行结果界面中,可以任意设定需要模拟的进程总数(如5),初始化进程个数(如3),还有A、B、C三类资源的总数(如10、10、10)。

相关文档
最新文档