昆明理工大学进程管理实验报告
进程管理实验报告
实验名称: 进程管理实验要求:阅读后面的C语言实例，修改程序，使其优先数在运行期间可以变化(动态优先数)。
例如，当某进程被时间片中断次数增加到一定数目时，提高其优先权。
关键问题:读懂源程序代码，了解进程管理的方式，并设计一个算法使程序能在运行过程中修改进程优先级。
设计思路:在进程控制块中定义一个记录进程中断次数的变量，在block函数中设置跟踪并记录进程中断次数，在调度函数schedule中设置算法，在进程中断3次后将该进程的优先级提升至最高。
改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态，'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针，指示在同一信号量上等待的下一个等待进程的进程号。
int priority; //进程优先数，值越小，优先级越高。
int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量；seed为随机值；registeri模拟寄存器值,存放计算的重复次数。
int registeri,s1,s2,seed,exe=NIL;//exe为当前运行（占有cpu）的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。
//对应信号量sem[0]、sem[1]分别有两个阻塞队列，队列首由sem[].firstwr指定，队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区，其中savearea[][0]为寄存器内容，savearea[][1]为下一条指令地址。
进程管理演示实验报告
一、实验目的1. 理解进程的概念及其在操作系统中的作用。
2. 掌握Linux系统中进程的创建、调度、同步和通信方法。
3. 熟悉进程的阻塞、挂起、恢复和终止操作。
4. 学习使用相关命令和工具进行进程管理和调试。
二、实验环境操作系统：Linux开发环境：GCC、Xshell三、实验内容1. 进程创建与调度2. 进程同步与通信3. 进程阻塞与恢复4. 进程终止与调试四、实验步骤1. 进程创建与调度（1）编写一个简单的C程序，使用fork()函数创建一个子进程。
（2）在父进程中，使用getpid()和getppid()函数获取进程ID和父进程ID。
（3）使用ps命令查看当前系统中的进程，观察父进程和子进程的状态。
（4）使用waitpid()函数等待子进程结束。
2. 进程同步与通信（1）编写一个使用管道（pipe）进行进程间通信的C程序。
（2）父进程向管道中写入数据，子进程从管道中读取数据。
（3）使用ps命令查看进程状态，观察管道通信的效果。
（4）编写一个使用信号量（semaphore）进行进程同步的C程序。
（5）使用sem_wait()和sem_post()函数实现进程同步。
3. 进程阻塞与恢复（1）编写一个使用sleep()函数使进程阻塞的C程序。
（2）在父进程中，使用waitpid()函数等待阻塞的子进程结束。
（3）使用kill()函数向阻塞的进程发送SIGCONT信号，使其恢复执行。
4. 进程终止与调试（1）编写一个使用exit()函数终止进程的C程序。
（2）在父进程中，使用waitpid()函数等待终止的子进程。
（3）使用gdb调试器分析程序运行过程中出现的问题。
五、实验结果与分析1. 进程创建与调度实验结果表明，使用fork()函数成功创建了子进程，父进程和子进程的进程ID和父进程ID被正确获取。
通过ps命令，可以观察到父进程和子进程的状态。
2. 进程同步与通信实验结果表明，管道通信可以成功实现父进程和子进程之间的数据传递。
操作系统-进程管理实验报告
操作系统-进程管理实验报告实验一进程管理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();操纵体系创建一个新的历程（子历程），而且在历程表中相应为它建立一个新的表项。
进程管理设计实验报告
一、实验目的1. 理解进程管理的概念和作用；2. 掌握进程的创建、调度、同步与通信等基本操作；3. 分析并解决进程管理中的常见问题；4. 提高编程能力和系统设计能力。
二、实验环境1. 操作系统：Linux；2. 编程语言：C/C++；3. 开发工具：GCC。
三、实验内容1. 进程创建与调度（1）创建一个简单的进程，实现进程的创建、运行和退出；（2）实现进程的调度，采用时间片轮转算法（RR）进行进程调度；（3）分析进程调度的过程，观察不同调度算法对进程执行的影响。
2. 进程同步与互斥（1）实现进程同步，采用信号量机制实现进程间的同步；（2）实现进程互斥，使用互斥锁（mutex）保护临界资源；（3）分析进程同步与互斥的原理，解决死锁、饥饿等问题。
3. 进程通信（1）实现进程间的通信，采用管道（pipe）进行数据传输；（2）实现共享内存（shared memory）进行进程间通信；（3）分析进程通信的原理，解决通信中的同步与互斥问题。
4. 实验拓展（1）设计一个多进程并发程序，实现生产者-消费者问题；（2）实现进程的优先级调度，观察不同优先级对进程执行的影响；（3）分析并实现进程的动态创建与销毁，提高系统的灵活性和可扩展性。
四、实验步骤1. 编写进程创建与调度的代码，实现进程的创建、调度和执行；2. 编写进程同步与互斥的代码，实现信号量机制和互斥锁；3. 编写进程通信的代码，实现管道和共享内存通信；4. 编写实验拓展的代码，实现生产者-消费者问题、优先级调度和动态创建与销毁；5. 编译并运行实验程序，观察实验结果，分析并解决问题。
五、实验结果与分析1. 进程创建与调度实验结果显示，采用时间片轮转算法（RR）进行进程调度，进程按照一定的顺序执行，实现了进程的并发执行。
2. 进程同步与互斥实验结果显示，采用信号量机制实现进程同步，可以避免进程间的冲突，保证进程按预期顺序执行；使用互斥锁（mutex）保护临界资源，可以防止多个进程同时访问同一资源，避免数据竞争。
进程管理实验报告分析(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. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
昆明理工大学理学院操作系统原理报告实验二任务管理器的进程管理
昆明理工大学（操作系统原理）实验报告实验名称实验二任务管理器的进程管理实验时间2013 年10 月8 日专业电科111 姓名 xxx 教师评语：学号200111110xxxx成绩教师签名Windows xp 任务管理器的进程管理1.背景知识Windows xp的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息，也显示了最常用的度量进程性能的单位。
使用任务管理器，可以打开监视计算机性能的关键指示器，快速查看正在运行的程序的状态，或者终止已停止响应的程序。
也可以使用多个参数评估正在运行的进程的活动，以及查看CPU的内存使用情况的图形和数据。
其中：（1）“应用程序”：这里显示所有当前正在运行的应用程序，但只会显示当前已打开窗口的应用程序，而不会显示已最小化系统托盘里的应用程序。
（2）“进程”：这里显示了所有当前正在运行的进程，包括应用程序、后台服务以及隐藏在系统底层深处的程序甚至是木马程序。
（3）“性能”：这里可以查看计算机性能的动态概念。
包括CPU和内存使用情况图表，正在运行的句柄、线程和进程的总数、物理、核心和认可的内存总数等。
2.实验目的通过Window任务管理器中对程序进程进行响应的管理操作系统进程管理的概念，学习观察操作系统运行的动态性能。
3.实验步骤1）启动并进入Windows，通过快捷键（Ctrl+Alt+Del）或鼠标(右键单击任务栏)启动“任务管理器”。
2）记录操作系统版本Microsoft Windows7 旗舰版Service Pack 3,“任务管理器”窗口的选项卡组成：文件选项查看关机帮助3）记录“进程”选项卡下内容（分用户记录并填入下表，进程数大于四的只记录四条）4）结束进程。
如果打开的程序与此进程相关联,则打开的程序将关闭,将丢失所有未保存的数据。
如果结束系统进程,则可能导致系统不稳定。
5）显示其他进程计数器。
在“进程”选项卡上单击“查看”菜单，然后单击“选择列”命令。
进程管理实验报告
实验报告纸（院、系）专业班组课实验一、进程管理(3学时、必做)一、实验目的通过实验使学生进一步了解进程、进程状态、进程控制等基本概念。
基本能达到下列具体的目标：1、理解进程PCB 的概念，以及PCB 如何实现、如何组织以及管理。
2、复习数据结构中如何对链的操作，包括建链、删除、插入结点等，来实现进程的管理。
二、实验内容1、建立一个结点，即PCB 块包括用户标识域、状态域（执行、等待、就绪）、link 域。
2、建立三个队列（执行队列、就绪队列、等待队列）。
3、根据进程状态转换实现对三个队列的具体操作。
具体的驱动可以采用时间片算法或手动调度的形式完成三个状态之间的转换4、用switch 选择语句选择状态。
5、按照自己的设定能完成所有的状态转换的运行（包括创建和运行结束）。
三、实验步骤1、复习进程管理三状态模型部分内容。
2、预习C++ Builder或VC++、Delphi、JBuilder线程编程。
3、运行示例程序，进一步明确实验要求。
可以采用控制台模式或窗口模式。
4、上机编程、调试程序。
5、完成实验报告。
四、实验过程1、进程管理三状态模型部分内容进程从因创建而产生直至撤销而消亡的整个生命周期中，有时占用处理器执行，有时虽然可以运行但分不到处理器，有时虽然处理器空闲但因等待某个事件发生而无法执行，这一切都说明进程和程序不同，进程是活动的且有状态变化，状态及状态之间的转换体现进程的动态性，为了便于系统管理，一般来说，按照进程在执行过程中的不同情况至少要定义三种进程状态。
(1)运行态：进程占用处理器运行的状态。
(2)就绪态：进程具备运行条件，等待系统分配处理器以便起运行的状态。
(3)等待态：进程不具备运行条件，正在等待某个时间完成的状态。
2、程序设计环境。
进程的管理实验报告结论
一、实验背景及目的进程是操作系统中基本的活动单位，进程管理是操作系统核心功能之一。
为了深入理解进程的概念、进程状态转换、进程同步与互斥等知识，我们进行了进程管理实验。
本次实验旨在通过编写程序，模拟进程的创建、调度、同步与互斥等操作，加深对进程管理的理解。
二、实验内容及方法1. 进程创建与状态转换（1）使用系统调用fork()创建子进程，观察父进程和子进程的状态转换过程。
（2）使用系统调用exec()替换子进程的内容，观察子进程状态变化。
2. 进程调度（1）编写进程调度程序，实现最高优先数优先调度算法和先来先服务调度算法。
（2）模拟进程就绪队列，观察调度算法对进程执行顺序的影响。
3. 进程同步与互斥（1）使用信号量实现进程同步，观察进程同步效果。
（2）使用互斥锁实现进程互斥，观察进程互斥效果。
4. 进程通信（1）使用管道实现进程间通信，观察通信效果。
（2）使用共享内存实现进程间通信，观察通信效果。
三、实验结果与分析1. 进程创建与状态转换实验结果显示，使用fork()创建子进程后，父进程和子进程的状态均为运行态。
当父进程调用exec()替换子进程内容后，子进程状态变为僵尸态，父进程状态变为运行态。
这说明进程在创建和替换过程中，其状态发生了相应的变化。
2. 进程调度实验结果显示，最高优先数优先调度算法和先来先服务调度算法均能正确执行。
最高优先数优先调度算法下，优先级高的进程先执行；先来先服务调度算法下，先到达的进程先执行。
这说明两种调度算法均能实现进程的合理调度。
3. 进程同步与互斥实验结果显示，使用信号量实现进程同步时，进程能正确地按照规定的顺序执行；使用互斥锁实现进程互斥时，进程能正确地实现互斥访问共享资源。
这说明信号量和互斥锁在进程同步与互斥方面具有重要作用。
4. 进程通信实验结果显示，使用管道实现进程间通信时，进程能正确地接收和发送数据；使用共享内存实现进程间通信时，进程能正确地访问共享内存中的数据。
进程管理实验报告
进程管理实验报告进程管理实验报告引言：进程管理是操作系统中的重要概念，它负责调度和控制计算机系统中的各个进程，确保它们能够有序地执行。
本实验旨在通过实际操作和观察，深入了解进程管理的原理和方法，并通过实验结果分析其影响因素和优化策略。
实验一：进程创建与终止在本实验中，我们首先进行了进程的创建和终止实验。
通过编写简单的程序，我们能够观察到进程的创建和终止过程，并了解到进程控制块（PCB）在其中的作用。
实验结果显示，当一个进程被创建时，操作系统会为其分配一个唯一的进程ID，并为其分配必要的资源，如内存空间、文件描述符等。
同时，操作系统还会为该进程创建一个PCB，用于存储该进程的相关信息，如进程状态、程序计数器等。
当我们手动终止一个进程时，操作系统会释放该进程所占用的资源，并将其PCB从系统中删除。
这样，其他进程便可以继续使用这些资源，提高系统的效率和资源利用率。
实验二：进程调度算法进程调度算法是决定进程执行顺序的重要因素。
在本实验中，我们通过模拟不同的进程调度算法，比较它们在不同场景下的表现和效果。
我们选择了三种常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）和轮转调度（RR）。
通过设置不同的进程执行时间和优先级，我们观察到不同调度算法对系统吞吐量和响应时间的影响。
实验结果显示，FCFS算法适用于执行时间较短的进程，能够保证公平性，但在执行时间较长的进程出现时，会导致等待时间过长，影响系统的响应速度。
SJF 算法在执行时间较长的进程时表现出色，但对于执行时间较短的进程，可能会导致饥饿现象。
RR算法能够在一定程度上平衡各个进程的执行时间，但对于执行时间过长的进程，仍然会影响系统的响应速度。
实验三：进程同步与互斥在多进程环境中，进程之间的同步和互斥是必不可少的。
在本实验中，我们通过模拟进程间的竞争和互斥关系，观察进程同步与互斥的实现方式和效果。
我们选择了信号量机制和互斥锁机制作为实现进程同步和互斥的方法。
进程管理实验报告
进程管理实验报告
摘要：
进程管理是操作系统中的重要概念之一，它涉及到进程的创建、调度和终止等方面。
本实验通过使用C语言编写一个简单的进程管
理程序来加深对进程管理原理的理解。
实验分为进程创建、调度和
终止三个部分，通过实验结果可以验证进程管理算法的正确性和效率。
1. 引言
进程是计算机中进行资源分配和调度的基本单位，它代表了一
个正在运行的程序。
进程管理是操作系统中的一个核心功能，负责
分配资源、调度进程和管理进程的状态等。
通过对进程管理的研究
和实验，可以深入了解操作系统的工作原理，并且优化进程管理算法，提高系统性能。
2. 实验目的
本实验的主要目的是通过编写一个进程管理程序，实现进程的创建、调度和终止等功能。
通过实验，验证进程管理算法的正确性和效率，并加深对进程管理原理的理解。
3. 实验环境
本实验使用C语言进行编程，采用Linux操作系统。
4. 实验内容
4.1 进程创建
进程创建是指操作系统为程序创建一个进程，使其能够在系统中运行。
在本实验中，我们使用fork()函数创建一个子进程，并通过exec()函数加载可执行文件。
4.2 进程调度
进程调度是指根据一定的算法选择哪个进程优先执行。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度等。
在本实验中，我们选择简单的先来先服务调度算法。
4.3 进程终止。
实验二-实验报告(进程管理)
实验二模拟实现进程管理组长：李和林软件1402一、实验目的1.理解进程的概念，明确进程和程序的区别。
2.理解并发执行的实质。
3.掌握进程的创建，睡眠，撤销等进程控制方法。
二、实验内容用C语言，JAVA语言，C++语言编写程序，模拟实现创建新的进程；查看运行进程，换出某个进程；杀死运行进程。
三、实验准备1.进程的定义进程是程序在一个数据集合上的运行过程，是系统资源分配和调度的一个独立单位。
一个程序在不同的数据集合上运行，乃至一个程序在同样数据集合上的多次运行都是不同的进程。
2.进程的状态通常情况下，一个进程必须具有就绪，执行和阻塞三种基本情况。
1)就绪状态当进程已分配到除处理器外的所有必要资源后，只要再获得处理器就可以立即执行，这时进程的状态就为就绪状态。
在一个系统里，可以有多个进程同时处于就绪状态，通常把这些就绪进程排成一个或多个队列，称为就绪队列。
2)执行状态处于就绪状态的进程一旦获得处理器，就可以运行，进程状态也就处于执行状态，在单处理器系统中，只能有一个进程处于执行状态，在多处理器系统中，则可能有多个进程处于执行状态3)阻塞状态正在执行的进程因为发生某些事件而暂停运行，这种受阻暂停的状态称为阻塞状态，也可称为等待状态。
通常将处于阻塞状态的进程拍成一个队列，称为阻塞队列，在有些系统中，也会按阻塞原因的不同将阻塞状态的进程排成多个队列。
3.进程状态之间的转换4.进程控制块1）进程控制块的作用进程控制块是进程实体的重要组成部分，主要包含下述四个方面的信息：a)进程标示信息b)说明信息c)现场信息d)管理信息5.进程控制块的组织方式1）链接方式2）索引方式6.进程控制原语1）创建原语2）撤销原语3）阻塞原语4）唤醒原语7.程序代码#include<stdio.h>#include<iostream>using namespace std;void clrscr();void create();void run( );void exchange( );//唤出void kill( );void wakeUp( );//唤醒struct process_type{int pid;int priority;//优先次序int size;int state;//状态char info[10];};struct process_type internalMemory[20];int amount=0,hangUp=0,pid,flag=0;//数目，挂起void main( ){int n;int a;n=1;clrscr( );while(n==1){cout<<"\n********************************************";cout<<"\n* 进程演示系统 *";cout<<"\n********************************************";cout<<"\n 1.创建新的进程 2.查看运行进程 ";cout<<"\n 3.换出某个进程 4.杀死运行进程 ";cout<<"\n 5.唤醒某个进程¨ 6.退出系统 ";cout<<"\n*********************************************"<<endl;cout<<"请选择 ";cin>>a;switch(a){case 1:create( );break;case 2:run( );break;case 3:exchange();//换出break;case 4:kill();break;case 5:wakeUp();break;case 6:exit(0);default:n=0;}}}void create(){ //创建进程int i=0;if (amount>=20){cout<<" 内存已满，请先结束或换出进程";}else{for (i=0;i<20;i++){if (internalMemory[i].state==0){break;}}cout<<"请输入新进程的pid: "<<endl;cin>>internalMemory[ i ].pid;cout<<"请输入新进程的优先级: "<<endl;cin>>internalMemory[amount].priority;cout<<"请输入新进程的大小: "<<endl;cin>>internalMemory[amount].size;cout<<"请输入新进程的内容: "<<endl;cin>>internalMemory[amount].info;internalMemory[i].state=1;amount++;}}void clrscr()//清除内存空间{for (int i=0;i<19;i++){internalMemory[i].pid=0;internalMemory[i].priority=0;internalMemory[i].size=0;internalMemory[i].state=0;}amount=0;}void run(){for (int i=0;i<20;i++){if (internalMemory[i].state==1){cout<<"当前内存中的进程：\n"<<endl;cout<<"当前运行的进程: ";cout<<internalMemory[i].pid<<endl;cout<<"当前运行进程的优先级: ";cout<<internalMemory[i].priority<<endl;cout<<"当前运行进程占用的空间大小: ";cout<<internalMemory[i].size;}}}void exchange( ){//唤出优先级最小的进程if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"\n输入换出进程的ID值: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=2;hangUp++;cout<<"\n已经成功换出进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换出的进程不存在";}else{cout<<"\n要换出的进程已被挂起\n";}flag=1;break;}}if (flag==0){cout<<"\n要换出的进程不存在";}}void kill( ){if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"请输入要杀死的进程: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=0;amount--;cout<<"此进程被杀死"<<pid;}else if (internalMemory[i].state==0){cout<<"\n要杀死的进程不存在\n";}else{cout<<"\n要杀死的进程已被挂起\n";}flag=1;break;}}if (!flag){cout<<"\n要杀死的进程不存在\n";}}void wakeUp(){if (!amount){cout<<"当前没有运行进程"<<endl;return;}if (!hangUp){cout<<"当前没有挂起进程";return;}cout<<"请输入pid: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){flag=0;if (internalMemory[i].state==2){internalMemory[i].state=1;hangUp--;cout<<"已经成功唤醒进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换醒的进程不存在\n";}else{cout<<"\n要唤醒的进程已被挂起\n";}break;}}if (flag){cout<<"\n要唤醒的进程已被挂起\n"<<endl;}}8.实现的结果。
实验进程管理实验报告
一、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。
2. 进一步认识并发执行的实质，理解进程的创建、调度、同步与通信。
3. 学习使用Linux系统中的进程管理命令，掌握进程的监控、控制与优化。
二、实验环境操作系统：Linux Ubuntu 20.04实验工具：终端（Terminal）、shell命令三、实验内容1. 进程的基本概念与特性2. 进程的创建与调度3. 进程同步与通信4. 进程的监控与优化四、实验步骤1. 进程的基本概念与特性（1）通过阅读相关资料，了解进程的概念、特性和生命周期。
（2）使用shell命令查看当前系统中进程的状态，如ps、top、htop等。
2. 进程的创建与调度（1）使用fork()函数创建进程，观察父子进程之间的关系。
（2）使用exec()函数替换子进程的映像，实现进程的创建。
（3）使用wait()、waitpid()等函数等待子进程结束，控制进程执行顺序。
（4）通过修改进程优先级，观察进程调度策略的变化。
3. 进程同步与通信（1）使用互斥锁（mutex）实现进程同步，防止数据竞争。
（2）使用条件变量（condition variable）实现进程间的条件同步。
（3）使用信号量（semaphore）实现进程间的同步与通信。
（4）通过管道（pipe）、消息队列（message queue）、共享内存（shared memory）等机制实现进程间的通信。
4. 进程的监控与优化（1）使用ps、top、htop等命令监控进程的运行状态。
（2）通过调整进程优先级，优化进程的执行顺序。
（3）使用renice命令调整进程的实时性。
（4）使用nice命令调整进程的调度策略。
五、实验结果与分析1. 进程的基本概念与特性通过实验，我们了解到进程是具有一定独立功能的程序关于某个数据集合的一次运行活动，具有并发性、动态性、独立性、异步性和结构特征等特性。
2. 进程的创建与调度实验过程中，我们成功创建了多个进程，并通过修改进程优先级，观察到调度策略的变化。
昆明理工大学进程管理实验报告
昆明理工大学信息工程与自动化学院学生实验报告（2010 —2011 学年第二学期）目录一、实验目的 (1)二、实验原理及基本技术路线图 (2)1.进程的状态转换图 (2)2.各原语的功能说明 (2)3.多级反馈队列调度算法的描述 (3)4.程序功能结构图 (4)5.流程图 (4)6.数据结构定义 (5)7.主要变量的说明 (6)8.函数的说明 (6)四、实验方法、步骤 (6)五、实验过程原始记录 (18)六、实验结果、分析和结论 (21)一、实验目的通过编写进程管理的算法，要求学生掌握整个进程管理的各个环节，进程的数据结构描述，进程的各种状态之间的转换，以及进程的调度算法。
以加深对进程的概念及进程调度算法的理解，并且提高链表的应用能力，达到提高编程能力的目的。
二、实验原理及基本技术路线图（方框原理图）用C语言或C++语言开发。
需要定义PCB的数据结构，用链表的形式管理进程，采用多级反馈队列调度的算法模拟进程的控制。
要求有创建、撤销、调度、阻塞、唤醒进程等功能。
1.进程的状态转换图：2.各原语的功能说明:-进程创建原语：进程创建是调用创建原语来实现。
创建原语扫描系统的PCB链表，在找到一定PCB 链表之后，填入调用者提供的有关参数（这些参数包括：进程名、进程优先级P0、进程正文段起始地址d0、资源清单R0等），最后形成代表进程的PCB结构。
-进程撤销（终止）: 撤消原语首先检查PCB进程链或进程家族，寻找所要撤消的进程是否存在。
如果找到了所要撤消的进程的PCB结构，则撤消原语释放该进程所占有的资源之后，把对应的PCB结构从进程链或进程家族中摘下并返回给PCB空队列。
如果被撤消的进程有自己的子进程，则撤消原语先撤消其子进程的PCB结构并释放子进程所占用的资源之后，再撤消当前进程的PCB结构和释放其资源。
-阻塞原语：当发生引起阻塞的事件时，该原语被该进程自己调用来阻塞自己。
阻塞原语在阻塞一个进程时，由于该进程正处于执行状态，故应先中断处理机和保存该进程的CPU 现场。
进程管理实验报告
进程管理实验报告一、引言进程管理是操作系统中的重要概念之一，它负责分配和调度计算机资源，确保多个程序能够同时运行，并通过合理的资源管理提高系统的效率和性能。
本实验旨在对进程管理进行深入研究和实践，通过编写相关代码并进行测试，探索进程管理的原理和实现方式。
二、实验背景在一个多道程序设计的环境中，操作系统需要管理系统中的各个进程，分配对应的资源，并处理进程之间的竞争条件。
进程管理的核心任务包括进程的创建、运行、阻塞、唤醒和终止等操作，以及资源的调度和分配。
三、实验目标本实验旨在通过编写一个简单的进程管理程序，实现进程的创建和调度，演示进程间的合作与竞争情况，以及资源的请求和释放。
具体目标包括：1.实现进程的创建和调度算法；2.模拟进程之间的竞争条件，如互斥、死锁等；3.模拟进程的请求和释放资源的过程；4.评估不同调度算法对系统性能的影响。
四、实验设计和方法1.进程创建和调度根据操作系统的调度算法，我们可以设计一个简单的进程调度器。
首先，需要定义进程的数据结构，包括进程ID、状态、优先级等信息。
其次，实现进程的创建函数，根据用户输入的参数来创建新的进程，并将其添加到进程队列中。
最后，根据调度算法，选择一个进程进行执行，并更新进程的状态。
2.进程间的竞争条件为了模拟进程间的竞争条件，我们可以使用互斥锁和信号量等同步机制。
通过在进程中设置临界区，限定同时只有一个进程可以访问临界资源，从而避免竞争和冲突。
另外，还可以模拟不同进程之间的死锁情况，观察系统的行为和响应。
3.进程的资源请求和释放在进程管理过程中，进程需要向系统申请资源，如内存、磁盘等。
为了模拟这一过程，我们可以设计一个简单的资源管理器，并在进程中调用相应的函数来请求和释放资源。
同时，可以设置资源的使用限制和优先级，观察不同策略对系统的影响。
4.评估系统性能为了比较不同调度算法对系统性能的影响，我们可以通过测量系统的响应时间、资源利用率和吞吐量等指标来评估。
进程管理_实验报告
一、实验目的1. 理解Linux操作系统中进程的概念，明确进程与程序的区别。
2. 掌握Linux下进程的创建、调度、同步与通信等基本操作。
3. 学会使用Linux命令查看和管理进程。
二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发工具：gcc、gdb三、实验内容1. 进程创建与调度2. 进程同步与互斥3. 进程通信4. 进程控制四、实验步骤1. 进程创建与调度（1）编写一个C程序，创建一个子进程，并在父进程中打印出子进程的进程标识符（PID）。
```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid;pid = fork(); // 创建子进程if (pid == 0) { // 子进程printf("子进程的PID：%d\n", getpid());} else if (pid > 0) { // 父进程printf("父进程的PID：%d，子进程的PID：%d\n", getpid(), pid); } else {printf("创建子进程失败\n");}return 0;}```（2）编译并运行程序，观察结果。
2. 进程同步与互斥（1）编写一个C程序，使用互斥锁（mutex）实现两个进程的同步。
```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 获取互斥锁printf("线程 %ld 获取了互斥锁\n", pthread_self());sleep(1);pthread_mutex_unlock(&mutex); // 释放互斥锁return NULL;}int main() {pthread_t thread1, thread2;pthread_mutex_init(&mutex, NULL); // 初始化互斥锁pthread_create(&thread1, NULL, thread_func, (void )1);pthread_create(&thread2, NULL, thread_func, (void )2);pthread_join(thread1, NULL);pthread_join(thread2, NULL);pthread_mutex_destroy(&mutex); // 销毁互斥锁return 0;}```（2）编译并运行程序，观察结果。
进程的管理和控制实验报告
进程的管理和控制实验报告实验目的：本实验旨在了解进程的管理和控制，掌握进程的创建、终止和状态转换等操作，并通过实际的代码编写和运行实验，加深对进程管理的理解。
实验原理：在操作系统中，进程是执行中的程序的实例。
进程管理涉及到创建新进程、终止现有进程、管理进程的状态等操作。
进程的创建：进程的创建可以通过系统调用fork()来完成。
fork()系统调用会创建一个新的进程，称为子进程，子进程将继承父进程的代码、数据和资源。
通过fork()的返回值来区分父子进程，父进程返回子进程的进程ID，子进程返回0。
进程的终止：进程的终止可以通过系统调用exit()来完成。
exit()系统调用会终止当前进程的执行，并返回一个退出状态码。
一个进程的终止也可以由其他进程通过发送终止信号来实现。
进程的状态转换：进程在执行过程中会经历不同的状态，包括就绪态、运行态、阻塞态等。
进程的状态转换可以通过系统调用来实现。
例如，当进程被阻塞时，可以通过系统调用sleep()将其状态转换为阻塞态，当等待的事件发生时，再将其状态转换为就绪态。
实验步骤：1. 编写一个简单的程序，包含进程的创建、终止和状态转换等操作。
2. 使用fork()系统调用创建子进程，并在子进程中执行一段代码。
3. 在父进程中对子进程进行管理，包括等待子进程的终止和获取子进程的退出状态码。
4. 在子进程中通过exit()系统调用终止进程的执行。
5. 在父进程中通过wait()系统调用等待子进程的终止，并获取子进程的退出状态码。
6. 在子进程中通过系统调用sleep()将进程的状态转换为阻塞态。
7. 在父进程中发送终止信号给子进程，观察子进程的终止情况。
实验结果与分析：经过实验，我们成功地创建了子进程并在子进程中执行了一段代码。
父进程能够正确地等待子进程的终止并获取子进程的退出状态码。
在子进程中使用sleep()系统调用后，观察到子进程的状态转换为阻塞态。
当父进程发送终止信号给子进程时，子进程能够正确地终止执行。
_进程管理实验报告
进程管理实验报告一、进程与线程1.实验目的：1.通过本实验学习Linux中创建进程的方法。
2.学习系统调用fork的使用方法。
3.学习系统调用exec族调用的使用方法。
2.实验准备1．进程的创建创建一个进程的系统调用很简单，只要调用fork函数就可以了。
#include<unistd.h>pid_t fork()；当一个进程调用了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族调用有以下五个函数：int execl(const char *path,const char*arg,…);int execlp(const char *file, const char*arg,…);int execle(const char *path,const char*arg,…);int execv(const char *path,const char*argv[]);int execvp(const char *file, const char*argv[]);exec族调用可以执行给定程序。
进程管理实验报告
进程管理实验报告1 ．实验目的通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。
【答：进程概念和程序概念最大的不同之处在于：(1)进程是动态的，而程序是静态的。
(2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。
没有建立进程的程序不能作为1个独立单位得到操作系统的认可。
(3)1个程序可以对应多个进程，但1个进程只能对应1个程序。
进程和程序的关系犹如演出和剧本的关系。
(4)进程和程序的组成不同。
从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。
而程序是一组有序的指令集合。
】2 ．实验内容(1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。
(2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。
(3) 编写一段程序，使用系统调用fork()来创建一个子进程。
子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“newprogram.”。
而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。
3 ．实验步骤（1）gedit创建进程1.c（2）使用gcc 1.c -o 1编译并./1运行程序1.c#include<stdio.h>#include <sys/types.h>#include <unistd.h>#include <sys/wait.h>void mian(){int id;if(fork()==0){printf(“child id is %d\n”,getpid());}else if(fork()==0){printf(“child2 id %d\n”,getpid());}else{id=wait();printf(“parent id is %d\n”,getpid());}}。
【操作系统实验报告实验一进程管理(20210814000319)】 进程管理实验报告
~~\r\n);
public void testblock()
(m);
{
m--;
rryList hblock1 = new rryList();
}
hblock1 = hblock;
// 输出就绪数组和堵塞数组的信息
pcb p = (pcb)list1[j];
public void outputll()
I!
\r\n=======CPU 运行了： + () + 次 =======\r\n);
I!
H*********当前就绪队列的信息！
I!
H*********
I!
当前就绪队列的信息！ *********);
//h
for (i = 1; i = n; i++)
为 运行的时间 片次 数，
{
time1Intevl
pcb jincheng = new pcb();
为时间片大小(毫秒)
= i;
// 对进程进行初始化，建立就绪数组、堵塞数组。
= () + 1);
public void input()//对进程进行初始化，建立就绪队列、堵塞队列
第1页共1页
本文格式为 Word 版，下载可任意编辑，页眉双击删除即可。
//r
n=;
为可随机产生的进程数
c=;
(r=m-n)
1=;
//
b1 = b;
，b，c 分别为 ，B，C 三类
c1 = c;
资源的总量
r = m - n;
//i
time1Intevl = ;
为进城计数，i=1…n
= time1Intevl;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
昆明理工大学信息工程与自动化学院学生实验报告（2010 —2011 学年第二学期）课程名称：操作系统开课实验室：年月日目录一、实验目的 (1)二、实验原理及基本技术路线图 (1)1. 进程的状态转换图 (2)2. 各原语的功能说明 (2)3.多级反馈队列调度算法的描述 (3)4. 程序功能结构图 (4)5. 流程图 (4)6. 数据结构定义 (5)7. 主要变量的说明 (6)8. 函数的说明 (6)四、实验方法、步骤 (6)五、实验过程原始记录 (18)六、实验结果、分析和结论 (21)一、实验目的通过编写进程管理的算法，要求学生掌握整个进程管理的各个环节，进程的数据结构描述，进程的各种状态之间的转换，以及进程的调度算法。
以加深对进程的概念及进程调度算法的理解，并且提高链表的应用能力，达到提高编程能力的目的。
二、实验原理及基本技术路线图（方框原理图）用C语言或C++语言开发。
需要定义PCB的数据结构，用链表的形式管理进程，采用多级反馈队列调度的算法模拟进程的控制。
要求有创建、撤销、调度、阻塞、唤醒进程等功能。
1.进程的状态转换图：2.各原语的功能说明:-进程创建原语：进程创建是调用创建原语来实现。
创建原语扫描系统的PCB链表，在找到一定PCB 链表之后，填入调用者提供的有关参数（这些参数包括：进程名、进程优先级P0、进程正文段起始地址d0、资源清单R0等），最后形成代表进程的PCB结构。
-进程撤销（终止）: 撤消原语首先检查PCB进程链或进程家族，寻找所要撤消的进程是否存在。
如果找到了所要撤消的进程的PCB结构，则撤消原语释放该进程所占有的资源之后，把对应的PCB结构从进程链或进程家族中摘下并返回给PCB空队列。
如果被撤消的进程有自己的子进程，则撤消原语先撤消其子进程的PCB结构并释放子进程所占用的资源之后，再撤消当前进程的PCB结构和释放其资源。
-阻塞原语：当发生引起阻塞的事件时，该原语被该进程自己调用来阻塞自己。
阻塞原语在阻塞一个进程时，由于该进程正处于执行状态，故应先中断处理机和保存该进程的CPU 现场。
然后将被阻塞进程置“阻塞”状态后插入等待队列中，再转进程调度程序选择新的就绪进程投入运行。
-唤醒原语：当等待队列中的进程所等待的事件发生时，等待该事件的所有进程都将被唤醒。
一个处于阻塞状态的进程不可能自己唤醒自己。
唤醒一个进程有两种方法：一种是由系统进程唤醒。
另一种是由事件发生进程唤醒。
当由系统进程唤醒等待进程时，系统进程统一控制事件的发生并将“事件发生”这一消息通知等待进程。
从而使得该进程因等待事件已发生而进入就绪队列。
等待进程也可由事件发生进唤醒。
由事件发生进程唤醒时，事件发生进程和被唤醒进程之间是合作关系。
因此，唤醒原语既可被系统进程调用，也可被事件发生进程调用。
我们称调用唤醒原语的进程为唤醒进程。
3.多级反馈队列调度算法的描述：(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。
第一个队列的优先级最高，第二个队列次之，其余各队列的优先权逐个降低。
该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。
例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第i+1个队列的时间片要比第i个队列的时间片长一倍。
图 3-5 是多级反馈队列算法的示意。
(2) 当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度。
当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业(进程)从第一队列依次降到第n队列后，在第n队列中便采取按时间片轮转的方式运行。
(3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1~(i-1) 队列均空时，才会调度第i队列中的进程运行。
如果处理机正在第i队列中为某进程服务时，又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列)，则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第i队列的末尾，把处理机分配给新到的高优先权进程。
4.程序功能结构图：5.流程图：6.数据结构定义：char name[20]; /*进程的名字*/int supernumber; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/ int count; /*记录执行的次数*/struct node *next; /*链表指针*/7.主要变量的说明：PCB *run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/ ReadyQueue *Head = NULL; /*定义第一个就绪队列*/int num; /*进程个数*/int ReadyNum; /*就绪队列个数*/8.函数的说明：void Output(); /*进程信息输出函数*/void InsertFinish(PCB *in); /*将进程插入到完成队列尾部*/void Insertsupernumber(ReadyQueue *in); /*创建就绪队列，规定优先数越小，优先级越低*/void supernumberCreate(); /*创建就绪队列输入函数*/void GetFirst(ReadyQueue *queue); /*取得某一个就绪队列中的队头进程*/void InsertLast(PCB *in,ReadyQueue *queue); /*将进程插入到就绪队列尾部*/void ProcessCreate(); /*进程创建函数*/void RoundRun(ReadyQueue *timechip); /*时间片轮转调度算法*/void MultiDispatch(); /*多级调度算法，每次执行一个时间片*/三、三、所用仪器、材料（设备名称、型号、规格等）。
计算机一台四、实验方法、步骤# include <stdio.h># include <stdlib.h># include <math.h># include <string.h>typedef struct node /*进程节点信息*/{char name[20]; /*进程的名字*/int supernumber; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;typedef struct Queue /*多级就绪队列节点信息*/{PCB *LinkPCB; /*就绪队列中的进程队列指针*/int supernumber; /*本就绪队列的优先级*/int round; /*本就绪队列所分配的时间片*/struct Queue *next; /*指向下一个就绪队列的链表指针*/}ReadyQueue;PCB *run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/ ReadyQueue *Head = NULL; /*定义第一个就绪队列*/int num; /*进程个数*/int ReadyNum; /*就绪队列个数*/void Output(); /*进程信息输出函数*/void InsertFinish(PCB *in); /*将进程插入到完成队列尾部*/void Insertsupernumber(ReadyQueue *in); /*创建就绪队列，规定优先数越小，优先级越低*/void supernumberCreate(); /*创建就绪队列输入函数*/void GetFirst(ReadyQueue *queue); /*取得某一个就绪队列中的队头进程*/void InsertLast(PCB *in,ReadyQueue *queue); /*将进程插入到就绪队列尾部*/ void ProcessCreate(); /*进程创建函数*/void RoundRun(ReadyQueue *timechip); /*时间片轮转调度算法*/void MultiDispatch(); /*多级调度算法，每次执行一个时间片*/void Output() /*进程信息输出函数*/{ReadyQueue *print = Head;PCB *p;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n");while(print){if(print ->LinkPCB != NULL){p=print ->LinkPCB;while(p){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->supernumber,p->round,p ->cputime,p->needtime,p->state,p->count);p = p->next;}}print = print->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->supernumber,p->round,p ->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->supernumber,p->round,p ->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void Insertsupernumber(ReadyQueue *in) /*创建就绪队列，规定优先数越小，优先级越低*/{ReadyQueue *fst,*nxt;fst = nxt = Head;if(Head == NULL) /*如果没有队列，则为第一个元素*/{in->next = Head;Head = in;}else /*查到合适的位置进行插入*/{if(in ->supernumber >= fst ->supernumber) /*比第一个还要大，则插入到队头*/{in->next = Head;Head = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void supernumberCreate() /*创建就绪队列输入函数*/{ReadyQueue *tmp;int i;static int j=0;printf("输入就绪队列的个数：\n");scanf("%d",&ReadyNum);printf("每个就绪队列的CPU时间片：(优先级和时间片成反比)\n");for(i = 0;i <ReadyNum; i++){if((tmp = (ReadyQueue *)malloc(sizeof(ReadyQueue)))==NULL){perror("malloc");exit(1);}tmp->round=int(pow(2.0,(++j))); /*输入此就绪队列中给每个进程所分配的CPU时间片*/printf("%d \n",tmp->round);tmp ->supernumber = 50 - tmp->round; /*设置其优先级，时间片越高，其优先级越低*/tmp ->LinkPCB = NULL; /*初始化其连接的进程队列为空*/tmp ->next = NULL;Insertsupernumber(tmp); /*按照优先级从高到低，建立多个就绪队列*/ }}void GetFirst(ReadyQueue *queue) /*取得某一个就绪队列中的队头进程*/ {run = queue ->LinkPCB;if(queue ->LinkPCB != NULL){run ->state = 'R';queue ->LinkPCB = queue ->LinkPCB ->next;run ->next = NULL;}}void ProcessCreate() /*进程创建函数*/{PCB *tmp;int i;static int j=1;printf("输入进程的个数：\n");scanf("%d",&num);for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}printf("输入%d进程名字：\n",j);scanf("%s",tmp->name);getchar();printf("输入%d进程时间：\n",j++);/*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->supernumber = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = Head ->round;tmp ->count = 0;InsertLast(tmp,Head); /*按照优先级从高到低，插入到就绪队列*/ }system("cls");}void InsertLast(PCB *in,ReadyQueue *queue) /*将进程插入到就绪队列尾部*/ {PCB *fst;fst = queue->LinkPCB;if( queue->LinkPCB == NULL){in->next = queue->LinkPCB;queue->LinkPCB = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void RoundRun(ReadyQueue *timechip) /*时间片轮转调度算法*/ {int flag = 1;GetFirst(timechip);while(run != NULL){while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == timechip ->round)/*时间片用完*/{run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/InsertLast(run,timechip);flag = 0;}}flag = 1;GetFirst(timechip);}}void MultiDispatch() /*多级调度算法，每次执行一个时间片*/ {int flag = 1;int k = 0;ReadyQueue *point;point = Head;GetFirst(point);while(run != NULL){Output();if(Head ->LinkPCB!=NULL)point = Head;while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/if(point ->next!=NULL){run ->round = point->next ->round;/*设置其时间片是下一个就绪队列的时间片*/InsertLast(run,point->next); /*将进程插入到下一个就绪队列中*/flag = 0;}else{RoundRun(point); /*如果为最后一个就绪队列就调用时间片轮转算法*/break;}}}flag = 1;if(point ->LinkPCB == NULL)/*就绪队列指针下移*/point =point->next;if(point ->next ==NULL){RoundRun(point);break;}GetFirst(point);}}int main( ){printf("\t\t\t\t进程管理\n");supernumberCreate(); /*创建就绪队列*/ProcessCreate();/*创建就绪进程队列*/printf("\t\t\t\t进程调度\n");for(int i=0;i<80;i++) printf("*");printf("\n");MultiDispatch();/*算法开始*/Output(); /*输出最终的调度序列*/return 0;}五、实验过程原始记录(数据、图表、计算等)六、实验结果、分析和结论（误差分析与数据处理、成果总结等。