(完整word版)操作系统实验报告 实验一 进程管理
操作系统实验报告进程管理
操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。
进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。
本实验报告将介绍进程管理的基本概念、原理和实验结果。
一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。
线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。
进程和线程是操作系统中最基本的执行单位。
2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。
就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。
3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。
常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。
二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。
通过PCB，操作系统可以对进程进行管理和控制。
2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。
进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。
进程的创建和撤销是操作系统中的基本操作之一。
3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。
常见的进程同步与通信机制包括互斥锁、信号量和管道等。
三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。
通过该程序，我们可以观察到不同调度算法对系统性能的影响。
实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。
(完整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中可执行文件在核心态运行和用户态运行的时间。
操作系统-进程管理实验报告
实验一进程管理1．实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）进一步认识并发执行的实质；（3）分析进程争用资源的现象，学习解决进程互斥的方法；（4）了解Linux系统中进程通信的基本原理。
2．实验预备内容（1）阅读Linux的sched.h源码文件，加深对进程管理概念的理解；（2）阅读Linux的fork()源码文件，分析进程的创建过程。
3．实验内容（1）进程的创建：编写一段程序，使用系统调用fork() 创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果，并分析原因。
源代码如下：#include<sys/types.h>#include<stdio.h>#include<unistd.h>#include <fcntl.h>#include <errno.h>int main(int argc,char* argv[]){pid_t pid1,pid2;pid1 = fork();if(pid1<0){fprintf(stderr,"childprocess1 failed");exit(-1);}1/12else if(pid1 == 0){printf("b\n");}else{pid2 = fork();if(pid2<0){fprintf(stderr,"childprocess1 failed");exit(-1);}else if(pid2 == 0){printf("c\n");}else{printf("a\n");sleep(2);exit(0);}}return 0;}结果如下：分析原因：pid=fork();操作系统创建一个新的进程（子进程），并且在进程表中相应为它建2/12立一个新的表项。
操作系统-进程管理实验报告
操作系统-进程管理实验报告实验一进程管理1．实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）进一步认识并发执行的实质；（3）分析进程争用资源的现象，研究解决进程互斥的方法；（4）了解Linux系统中进程通信的基本原理。
2．实验预备内容（1）阅读Linux的sched.h源码文件，加深对进程管理概念的理解；（2）阅读Linux的fork()源码文件，分析进程的创建过程。
3．实验内容（1）进程的创建：编写一段程序，使用系统调用fork()创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果，并分析原因。
源代码如下：#include<XXX>#include<XXX>#include<unistd.h>#include <XXX>#include <XXX>int main(int argc,char* argv[]){pid_t pid1,pid2;pid1 = fork();if(pid1<0){fprintf(stderr,"childprocess1 failed");exit(-1);}else if(pid1 == 0){printf("b\n");}else{pid2 = fork();if(pid2<0){fprintf(stderr,"childprocess1 failed"); exit(-1);}else if(pid2 == 0){printf("c\n");}else{printf("a\n");sleep(2);exit(0);}}return 0;}结果如下：分析原因：pid=fork();操纵体系创建一个新的历程（子历程），而且在历程表中相应为它建立一个新的表项。
进程管理实验报告分析(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、掌握Linux中进程的创建方法及执行情况；2、加深对进程、进程树等概念的理解；3、掌握Linux中如何加载子进程自己的程序；4、掌握父进程通过创建子进程完成某项任务的方法；5.、掌握系统调用exit()和_exit()调用的使用。
6、分析进程竞争资源的现象，学习解决进程互斥的方法；进一步认识并发执行的实质二、实验内容（一）进程的创建1、编写一段程序，使用系统调用fork( )创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符。
#include<stdio.h>main(){int p,x;p=fork();if(p>0){x=fork();if(x>0)printf("father\n");elseprintf("child2");}elseprintf("child1");}输出结果：child1child2father2、运行以下程序，分析程序执行过程中产生的进程情况。
#include <stdio.h>main(){int p,x;p=fork();if (p>0)fork();else{fork();fork();}sleep(15);}实验步骤：编译连接gcc –o forktree forktree.c后台运行./forktree &使用pstree –h 查看进程树运行结果：├─gnom e-terminal─┬─bash─┬─forktree─┬─forktree─┬─forkt ree───forktree││││└─forktree│││└─forktree││└─pstree 分析：程序运行，系统首先创建一个进程forktree,执行到p=fork()创建一个子进程forktree，子进程获得处理机优先执行，父进程等待；执行else，当执行到第一个fork()函数时，子进程创建了一个进程forktree，称之为孙进程，孙进程获得处理机往下执行，子进程等待；执行到第二个fork()函数时，孙进程又创建一个进程forktree，称之为重孙进程，重孙进程很快执行完，将处理机还给孙进程，孙进程很快执行完，将处理机还给子进程；子进程继续往下执行，执行到第二个fork()函数，又创建一个进程forktree，称之为第二孙进程，并获得处理机执行，此进程很快执行完，将处理机还给子进程，子进程也很快执行完，将处理机还给父进程，父进程P>0执行if语句，运行fork()函数，又创建一个进程forktree，称之为第二子进程，此进程获得处理机执行很快运行完，将处理机还给父进程，父进程运行sleep(15)语句，休眠15秒，用pstree命令查询进程树。
操作系统进程管理实验报告
操作系统进程管理实验报告一、引言在现代计算机科学中，操作系统的进程管理是确保系统高效运行的关键环节。
本实验旨在通过观察和分析操作系统的进程管理行为，深入理解进程的创建、运行和终止过程，以及操作系统如何对进程进行调度和资源分配。
二、实验目标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. 创建进程：能够创建新的进程，并为其分配资源。
2. 进程调度：能够根据进程的优先级和调度算法，合理地调度进程的执行顺序。
3. 进程同步：能够实现进程间的同步与互斥，避免资源竞争和死锁问题。
二、实验环境和工具本实验使用的实验环境和工具如下：1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验过程和结果1. 进程创建在实验中，我们首先实现了进程的创建功能。
通过调用操作系统提供的系统调用接口，我们能够创建新的进程，并为其分配资源。
具体的实现过程涉及到进程控制块（PCB）的创建和初始化，以及资源的分配和管理。
通过编写测试程序，我们成功创建了多个进程，并验证了进程创建功能的正确性。
2. 进程调度进程调度是操作系统中非常重要的功能之一，它决定了进程的执行顺序和时间片的分配。
在实验中，我们实现了简单的进程调度算法，采用了轮转调度算法。
通过设计合适的数据结构和算法，我们能够按照一定的优先级和时间片大小，合理地安排进程的执行顺序。
通过编写测试程序，我们验证了进程调度功能的正确性。
3. 进程同步在多进程环境下，进程间的同步与互斥是非常重要的问题。
在实验中，我们实现了进程同步功能，通过使用信号量和互斥锁，实现了进程间的同步与互斥。
通过编写测试程序，我们验证了进程同步功能的正确性，并且能够避免资源竞争和死锁问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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));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("*********当前就绪队列的信息！*********");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++){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）。