基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现资料
进程调度模拟算法
进程调度模拟算法进程调度是操作系统中的重要组成部分之一，它负责决定在多道程序环境下，哪个进程将获得CPU的使用权。
进程调度模拟算法是为了研究和评估不同调度策略的性能而开发的一种仿真方法。
在实际系统中，调度算法会受到多种因素的影响，如进程优先级、进程的I/O需求、进程的实际执行时间等。
通过模拟这些因素，可以更好地理解不同调度算法之间的差异，并选择最合适的算法来满足特定需求。
下面介绍两种常见的进程调度模拟算法：先来先服务（FCFS）和最短作业优先（SJF）算法。
1. 先来先服务（FCFS）算法：该算法按照进程到达的顺序来调度任务。
当一个进程完成或阻塞时，下一个已到达的进程将获得CPU的使用权。
这种算法非常简单，但是不适用于长作业时间和短作业时间交替出现的情况。
在短作业启动时，长作业仍然在运行，使得短作业的等待时间增加。
2. 最短作业优先（SJF）算法：该算法根据任务的执行时间来调度进程。
在该算法中，每个进程的执行时间都是已知的，并且操作系统根据已知的执行时间来决定哪个进程获得CPU的使用权。
在短作业优先算法中，短作业将会先被调度，这样有助于减少平均周转时间和等待时间。
但是，短作业优先算法容易产生“饥饿”现象，即长作业可能会一直等待，而短作业一直得到CPU的使用权。
除了以上两种算法，还有其他的进程调度模拟算法。
例如：- 时间片轮转（RR）调度算法：使用固定的时间片来调度进程，当时间片用完后，该进程被放入就绪队列的末尾。
- 优先级调度算法：每个进程都拥有一个优先级，优先级越高的进程越早被调度。
这种方法可以根据不同进程的紧迫程度和重要性来进行调度。
- 多级反馈队列调度算法：将就绪队列划分为多个队列，并根据进程的性质和优先级将进程放入不同的队列。
每个队列都有不同的优先级和时间片大小，进程可以通过提高优先级或时间片大小来提高被调度的机会。
在实际应用中，需要根据系统需求和性能指标选择合适的调度算法。
常用的性能指标包括平均周转时间、平均等待时间、CPU利用率等。
多级反馈算法 -回复
多级反馈算法-回复多级反馈算法(Multi-level Feedback Queue Scheduling Algorithm)是一种常用的调度算法，主要应用于操作系统中的进程调度。
该算法的核心思想是根据进程的行为特征和优先级将进程分配到不同的队列中，并根据每个队列的特点进行合理的调度。
在传统的操作系统中，通常使用先来先服务(FCFS)或者优先级调度算法。
然而，这些算法存在一些问题。
比如，FCFS无法充分利用系统资源，造成长作业的等待时间过长；而优先级调度算法又可能导致低优先级进程永远得不到调度。
为了更好地解决这些问题，多级反馈算法应运而生。
首先，我们来了解一下多级反馈算法的基本原理。
该算法将进程分成多个队列，并为每个队列分配不同的时间片大小。
一般来说，最高优先级的队列时间片最小，而最低优先级的队列时间片最大。
当一个进程进入系统时，首先被分配到最高优先级的队列中。
如果该进程在时间片结束前完成，那么它就会被移出队列，否则它将被移到下一个优先级更低的队列中。
这样，高优先级的队列会得到更多的CPU时间，从而提高整体系统的执行效率。
接下来，我们详细解析多级反馈算法的具体流程。
首先，系统会为每个队列分配一个时间片大小，一般而言，高优先级队列的时间片相对较小，低优先级队列的时间片较大。
当一个进程进入系统时，它会被放置在最高优先级队列，并被分配时间片。
如果该进程在时间片耗尽前完成，它会被移出队列，并不再分配时间片。
如果该进程在时间片结束前未能完成，它会被移到下一个优先级更低的队列中，并继续等待。
这样，每个队列都有机会被调度执行，从而提高系统资源利用率。
在实际应用中，多级反馈算法还可以根据进程的行为特征进行动态调整。
比如，对于经常I/O阻塞的进程，可以将其移至低优先级队列，以避免占用过多的CPU时间。
而对于经常计算密集型的进程，可以将其移至高优先级队列，以提高其执行效率。
这种根据进程行为特征的动态调整，可以进一步提升系统的性能和响应速度。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。
三、实验过程。
1. 先来先服务（FCFS）调度算法。
先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。
在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。
实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。
2. 最短作业优先（SJF）调度算法。
最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。
在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。
实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。
3. 时间片轮转（RR）调度算法。
时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。
在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。
实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。
4. 多级反馈队列（MFQ）调度算法。
多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。
在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。
实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。
四、实验总结。
通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。
多级反馈队列调度算法的原理
多级反馈队列调度算法的原理1.多级反馈队列调度算法是一种常见的进程调度算法，旨在平衡系统的吞吐量、响应时间和公平性。
它采用多个队列，每个队列有不同的优先级，进程根据其行为在这些队列之间移动。
本文将详细介绍多级反馈队列调度算法的原理和工作方式。
2. 算法概述多级反馈队列调度算法的核心思想是通过不同优先级的队列来对进程进行调度。
每个队列有不同的时间片大小，高优先级队列的时间片较小，低优先级队列的时间片较大。
当一个进程在当前队列中运行完时间片，它将被移动到下一优先级的队列。
如果一个进程在某个队列运行完时间片后还没有执行完，它将继续在当前队列等待，以便有更多的机会执行。
3. 多级队列结构典型的多级反馈队列调度算法包括多个队列，通常包括三个或更多级别。
每个队列的优先级不同，如高、中、低。
时间片大小逐渐增大，高优先级队列的时间片小于中优先级，中优先级小于低优先级。
4. 调度过程4.1 进程到达当一个新进程到达系统时，它被分配到最高优先级队列。
4.2 运行和时间片耗尽进程在当前队列中运行，如果它的时间片耗尽，它将被移动到下一优先级的队列。
如果进程在当前队列没有完成执行，它将在下一次调度时继续运行。
4.3 优先级提升如果一个进程在低优先级队列等待了很长时间，系统可能会将其提升到高优先级队列，以确保长时间等待的进程有机会获得更多的CPU 时间。
5. 优点5.1 响应时间短由于高优先级队列的时间片较小，进程在高优先级队列中能够更快地执行，因此系统的响应时间相对较短。
5.2 吞吐量高对于短时间运行的进程，能够快速地在高优先级队列中完成执行，有助于提高系统的吞吐量。
5.3 公平性低优先级队列的时间片较大，长时间运行的进程有足够的机会在低优先级队列中执行，增加了系统的公平性。
6. 缺点6.1 管理复杂性多级反馈队列调度算法需要维护多个队列，涉及到队列的调度和进程的迁移，因此管理和实现相对复杂。
6.2 死锁可能如果系统中的进程都是长时间运行的，并且高优先级队列的时间片较小，可能导致低优先级队列中的进程长时间等待，进而引发死锁问题。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有5个进程要运行在一个单核处理器上，每个进程有不同的运行时间和优先级。
进程信息如下：进程A：运行时间10ms，优先级4进程B：运行时间8ms，优先级3进程C：运行时间6ms，优先级2进程D：运行时间4ms，优先级1进程E：运行时间2ms，优先级5实验步骤：1.先来先服务（FCFS）调度算法实验：将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
2.最短作业优先（SJF）调度算法实验：将上述进程按照运行时间的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
3.优先级调度算法实验：将上述进程按照优先级的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
4.时间片轮转（RR）调度算法实验：设置一个时间片大小，将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
实验结果：通过模拟实验，我们可以得到每个进程的运行时间、完成时间和等待时间。
对于FCFS算法，进程的运行顺序是按照先来先服务的原则，因此进程A首先得到处理器资源并完成运行，其它进程依次按照到达顺序得到资源。
因此，对于进程A、B、C、D、E，它们的完成时间分别是10ms、18ms、24ms、28ms和30ms，等待时间分别是0ms、10ms、18ms、24ms和28ms。
对于SJF算法，进程的运行顺序是按照运行时间的大小，即短作业优先。
因此，进程E首先得到处理器资源并完成运行，其它进程依次按照运行时间的大小得到资源。
对于进程E、D、C、B、A，它们的完成时间分别是2ms、6ms、12ms、20ms和30ms，等待时间分别是0ms、2ms、6ms、12ms和20ms。
反馈调度算法实验报告
一、实验目的本次实验旨在通过模拟操作系统中的反馈调度算法，加深对进程调度过程的理解，掌握不同调度算法的原理和实现方法，并分析其优缺点。
实验内容包括实现三种反馈调度算法：先来先服务（FCFS）、时间片轮转（RR）和多级反馈队列（MFQ）。
二、实验内容1. 数据结构设计本实验采用进程控制块（PCB）来表示进程，PCB包含以下信息：- 进程名- 到达时间- 需要运行时间- 已运行时间- 进程状态（就绪、运行、完成）2. 调度算法实现（1）先来先服务（FCFS）调度算法FCFS算法按照进程到达就绪队列的顺序进行调度，即先到达的进程先执行。
具体实现步骤如下：- 将所有进程按到达时间排序，形成就绪队列。
- 当CPU空闲时，从就绪队列中取出第一个进程执行，执行完毕后，再取出下一个进程执行。
（2）时间片轮转（RR）调度算法RR算法将CPU时间划分为时间片，每个进程轮流占用CPU执行一个时间片。
具体实现步骤如下：- 将所有进程按到达时间排序，形成就绪队列。
- 当CPU空闲时，从就绪队列中取出第一个进程执行，执行一个时间片。
- 如果进程执行完毕，则将其状态设置为完成；如果进程未执行完毕，则将其状态设置为就绪，并插入就绪队列末尾。
- 继续执行下一个进程，直到所有进程执行完毕。
（3）多级反馈队列（MFQ）调度算法MFQ算法将就绪队列分为多个优先级队列，每个队列具有不同的时间片长度。
具体实现步骤如下：- 将所有进程按到达时间排序，形成就绪队列。
- 将就绪队列分为多个优先级队列，优先级越高，时间片越短。
- 当CPU空闲时，从最高优先级队列中取出第一个进程执行，执行一个时间片。
- 如果进程执行完毕，则将其状态设置为完成；如果进程未执行完毕，则将其状态设置为就绪，并插入下一个优先级队列的末尾。
- 如果当前优先级队列中的所有进程都执行完毕，则降低优先级，继续执行下一个优先级队列的进程。
三、实验结果分析1. FCFS算法FCFS算法简单易实现，但存在“饥饿”现象，即低优先级进程可能长时间得不到调度。
反馈调度算法实验报告
反馈调度算法实验报告引言反馈调度算法是操作系统中常用的调度算法之一，它以时间片为单位，将进程划分为多个优先级队列，根据优先级和时间片长度来决定进程执行的顺序。
本实验旨在通过实际操作观察和比较不同的反馈调度算法在不同场景下的表现，并分析其优缺点。
实验目的1. 了解反馈调度算法的原理和实现方式；2. 熟悉使用模拟器进行实验的方法；3. 分析和评估不同反馈调度算法在不同场景下的表现。
实验环境- 操作系统：Windows 10- 开发工具：Visual Studio Code- 模拟器：C++ 编写的模拟器实验过程1. 实验准备首先，我们选择了Round Robin、Multilevel Feedback Queue 和Weighted Round Robin 三种反馈调度算法进行实验。
并计划使用不同的进程数据集来模拟不同的场景。
2. 实验步骤2.1 实验一：Round Robin 调度算法在第一个实验中，我们准备了一个包含3 个进程的数据集，每个进程分别需要执行不同的时间。
我们设置了一个时间片长度为2 个时间单位。
通过模拟器运行实验，观察每个进程的执行顺序和等待时间。
2.2 实验二：Multilevel Feedback Queue 调度算法在第二个实验中，我们准备了一个包含5 个进程的数据集，每个进程的时间片长度会随着优先级的提高而增加。
我们设置了3 个优先级队列，初始时间片长度分别为1、2 和4 个时间单位。
通过模拟器运行实验，观察不同优先级队列中进程的执行情况。
2.3 实验三：Weighted Round Robin 调度算法在第三个实验中，我们准备了一个包含4 个进程的数据集，每个进程的时间片长度由权重决定。
我们设置了进程的权重分别为1、2、3 和4。
通过模拟器运行实验，观察不同权重的进程在调度中的表现。
3. 实验结果与分析通过观察实验结果，我们得到了不同调度算法在不同场景下的表现。
对于Round Robin 调度算法，它公平地轮流执行每个进程，避免了进程长时间等待，但当进程的执行时间过长时，会导致延迟增加。
模拟调度实验报告(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算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
(完整word版)基于反馈(FeedBack,FB)排队算法的CPU调度的模拟实现资料
JLU《操作系统》课程设计[基于反馈（Feed Back，FB）排队算法的CPU调度的模拟实现]算法设计：多级反馈队列调度算法，不必事先知道各进程所需的进程时间，而且还可以满足各种类型进程的需要，因而它是目前被公认的一种较好的进程调度算法。
在采用多级反馈队列调度算法的系统中，调度算法的实施过程如下：1．设置多个就绪队列，并为各个队列赋予不同的优先级。
第一个队列的优先权最高，第二个的次之，其余各队列的优先权逐个降低。
该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。
例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第I+1个队列的时间片要比第I个队列的时间片长一倍。
2．一个新进程进入内存后，首先将它放在第一队列的末尾，按FCFS原则排队等待调度。
当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统，如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业（进程）从第一队列依次降到第n队列后，在第n队列中便采取按时间片轮转的方式进行。
3．仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1~（I-1）队列均空时，才会调度第I队列中为某进程服务时，又有新进程进入优先权较高的队列（第1~（I-1）中的任何一个队列），则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第I队列的末尾，把处理机分配给新到的高优先权进程。
任务分工及各分工实现方法：组长学号及姓名：分工：一直以来担任组长，要做的事很多，既要给组员分排任务，安排每个人的在课程设计要完成的任务，又要协调各个之间的分歧与合作，尽量融合大家的各种想法，汇总好的建议，好的做法，达到我们组的团体合作精神，这样才能把课程设计做的更好。
进程调度算法模拟程序设计
进程调度算法模拟程序设计引言进程调度算法是操作系统中的重要组成部分，它决定了进程在系统中的执行顺序和分配时间片的策略。
为了更好地理解和研究不同的进程调度算法，我们可以设计一个模拟程序来模拟进程的调度过程。
本文将介绍进程调度算法的基本概念和常见的调度算法，并详细讨论如何设计一个进程调度算法模拟程序。
什么是进程调度算法进程调度算法是操作系统中的一种策略，用于决定在多个进程同时请求执行时，系统按照什么样的顺序来选择并分配CPU资源。
进程调度算法的目标是尽可能地提高系统的吞吐量、响应时间和公平性。
常见的进程调度算法先来先服务（FCFS）先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度。
当一个进程到达系统后，它会被放入就绪队列中，然后按照先后顺序执行。
这种算法的优点是简单易懂，但是存在”饥饿”问题，即长作业会占用CPU资源，导致其他短作业等待时间过长。
短作业优先（SJF）短作业优先算法是根据进程的执行时间来进行调度的。
当一个进程到达系统后，系统会根据其执行时间将其放入适当的位置，执行时间短的进程优先执行。
这种算法可以最大限度地减少平均等待时间，但是对于长作业来说可能会饥饿。
时间片轮转（RR）时间片轮转算法是一种分时调度算法，它将CPU的执行时间划分为多个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程。
这种算法可以保证所有进程都有机会执行，并且对于响应时间要求较高的任务比较合适。
多级反馈队列（MFQ）多级反馈队列算法是一种综合了FCFS和RR的调度算法。
系统将进程根据优先级划分为多个队列，每个队列都有不同的时间片大小。
当一个进程到达系统后，它被放入第一个队列中，如果在时间片内没有执行完，则被移到下一个队列中。
这种算法可以根据进程的优先级和执行时间动态调整调度策略，提高系统的响应性能。
进程调度算法模拟程序设计程序结构为了设计一个进程调度算法模拟程序，我们需要考虑以下几个方面的内容：1.进程的数据结构：我们可以使用一个进程控制块（PCB）来表示一个进程，PCB包含了进程的状态、优先级、执行时间等信息。
多级队列调度算法和多级反馈队列调度算法
多级队列调度算法和多级反馈队列调度算法在计算机操作系统中，进程调度是指根据一定的策略从就绪队列中选择一个进程分配CPU时间片，使得多个进程能够合理高效地共享CPU资源。
多级队列调度算法和多级反馈队列调度算法是两种常见的进程调度算法。
本文将分别介绍这两种调度算法的原理和特点。
一、多级队列调度算法多级队列调度算法是一种基于优先级的调度算法，将就绪进程划分为多个队列，每个队列具有不同的优先级，其中优先级高的队列具有更高的调度优先级。
调度器按照优先级从高到低的顺序选择进程执行，同一优先级的进程按照先到先服务的原则进行调度。
多级队列调度算法的主要特点如下：1. 简单高效：多级队列调度算法简单直观，易于实现和理解。
由于进程被划分到不同的队列中，能够更好地满足不同进程的调度需求。
2. 公平性：多级队列调度算法可以根据进程的优先级来确定调度顺序，优先级高的进程能够更早地被执行，提高了进程的响应速度。
3. 适应性：多级队列调度算法可以根据不同进程的调度需求来设置不同的优先级，能够更好地满足不同进程的执行要求。
然而，多级队列调度算法也存在一些问题。
例如，如果某个队列中的进程过多，可能会导致低优先级队列的进程长时间得不到执行，影响系统的整体性能。
为了解决这个问题，引入了多级反馈队列调度算法。
二、多级反馈队列调度算法多级反馈队列调度算法是在多级队列调度算法的基础上进行改进的一种调度算法。
它引入了时间片的概念，并允许进程在不同的队列之间移动。
每个队列具有不同的时间片大小和优先级，当一个进程的时间片用完后，它会被移到下一个优先级更低的队列中。
多级反馈队列调度算法的主要特点如下：1. 公平性：多级反馈队列调度算法兼顾了优先级和时间片的概念，能够更加公平地分配CPU时间片，避免某个队列中的进程长时间得不到执行。
2. 弹性：多级反馈队列调度算法能够根据进程的执行情况灵活地调整进程的优先级和时间片大小，提高系统的响应速度和吞吐量。
操作系统各种调度算法
操作系统各种调度算法操作系统的调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序和调度策略。
不同的调度算法应用于不同的场景和需求，目的是提高CPU利用率、降低响应时间、提高吞吐量等。
本文将介绍几种常见的调度算法，包括先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）、时间片轮转调度算法（RR）和多级反馈队列调度算法（MFQ）。
先来先服务调度算法（FCFS）是最简单的调度算法之一，该算法按照进程到达的先后顺序分配CPU资源。
当一个进程在CPU上执行时，其他进程需要等待，直到该进程完成。
FCFS调度算法具有易于实现和公平性的优点，但是由于没有考虑进程的执行时间，可能导致长作业的久等和短作业的饥饿问题。
最短作业优先调度算法（SJF）根据进程的预计执行时间来调度。
该算法假设可以获得每个进程的执行时间，并选择执行时间最短的进程执行。
SJF调度算法可以最小化平均等待时间和响应时间，但是由于无法准确预测进程的执行时间，可能导致长作业的饥饿问题。
时间片轮转调度算法（RR）将CPU时间切分成固定长度的时间片，每个进程在一个时间片中执行。
当一个进程的时间片用完后，系统将该进程重新加入到就绪队列的末尾，让其他就绪进程获得CPU执行。
RR调度算法能够保证每个进程都能获得一定的CPU时间，但是当进程的执行时间过长时，可能需要频繁的上下文切换，导致系统开销增加。
多级反馈队列调度算法（MFQ）是一种结合了FCFS和RR的调度算法。
该算法将就绪队列划分成多个队列，每个队列有不同的优先级，并且每个队列采用RR调度算法。
进程首先进入高优先级队列，如果时间片用完仍未完成，则降低优先级进入下一级队列，直到最低优先级队列。
此时，进程将拥有更长的时间片并能够执行较长时间。
MFQ调度算法兼顾了短作业的优先执行和长作业的公平性，但是需要根据实际情况设置多个队列和时间片长度，较为复杂。
除了以上介绍的几种调度算法，还有其他一些调度算法可供选择，如最高响应比优先调度算法（HRRN）、最早截止时间优先调度算法（EDF）等。
非抢占式多级反馈队列调度算法
非抢占式多级反馈队列调度算法非抢占式多级反馈队列调度算法是一种常用的进程调度算法，也是操作系统领域中非常经典和重要的一个概念。
在操作系统中，进程调度是指操作系统对进程进行选择和分配处理器的过程，而多级反馈队列调度算法是其中一种常见的调度策略。
一、多级反馈队列调度算法的基本原理1.1 多级反馈队列的设置多级反馈队列调度算法通过设置多个队列，每个队列具有不同的优先级，来实现对进程的调度。
一般来说，优先级高的队列具有更高的调度优先级，而优先级低的队列具有较低的调度优先级。
当一个进程到达系统时，首先被放入最高优先级的队列中，如果在一个时间片内没有执行完毕，则将其移动到优先级稍低的队列中，以此类推，直到进程执行完毕或者被放入最低优先级的队列中。
1.2 时间片的设定在多级反馈队列调度算法中，不同队列具有不同的时间片大小，一般来说，优先级高的队列具有较短的时间片，而优先级低的队列具有较长的时间片。
这样设计的好处是，能够兼顾高优先级进程的及时响应和低优先级进程的长时间执行。
1.3 调度策略多级反馈队列调度算法的核心在于其调度策略。
一般来说，即使在同一优先级的队列中，也采用先来先服务的策略，即按照进程到达的顺序进行调度。
而在不同优先级的队列之间，则按照各自的调度策略来执行。
二、多级反馈队列调度算法的实现在实际的操作系统中，多级反馈队列调度算法的实现需要考虑诸多因素。
首先是如何设置各个队列的优先级和时间片大小，需要根据具体的系统特点和需求来进行调整。
其次是如何具体实现调度策略，包括进程的进入队列和离开队列的条件、时间片的划分和分配等细节问题。
针对不同的操作系统，可能会有不同的实现方式和优化方法。
三、对非抢占式多级反馈队列调度算法的个人理解和观点在我看来，非抢占式多级反馈队列调度算法是一种非常灵活和高效的调度策略。
它能够兼顾到各个进程的优先级和执行时间，既能够保证高优先级进程的及时响应，又能够充分利用处理器资源，提高系统的整体吞吐量。
c语言实现多级反馈队列调度的算法模拟进程的控制
c语言实现多级反馈队列调度的算法模拟进程的控制目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 多级反馈队列调度算法2.1 基本原理2.2 算法设计思路2.3 算法流程图3. C语言实现模拟进程控制3.1 数据结构定义3.2 进程创建与销毁3.3 进程调度与执行4. 实验结果与分析4.1 实验环境介绍4.2 实验结果展示4.3 结果分析与讨论5. 结论与展望5.1 结论总结5.2 存在问题与改进方向1. 引言1.1 背景和意义在计算机科学领域，进程调度是操作系统中非常重要的一个功能。
它负责决定哪个进程可以使用CPU并以何种顺序执行。
进程调度算法的优劣直接影响了系统的性能和效率。
多级反馈队列调度算法是一种常用的进程调度算法之一，它可以根据进程的类型和优先级将进程划分到不同的队列中，并根据优先级来决定进程的执行顺序。
该算法兼具公平性和高响应时间两个特点，适合应用于多任务环境下。
本文旨在使用C语言实现模拟多级反馈队列调度算法，并通过模拟进程控制过程，探讨其在实际应用中的表现。
通过实验结果与分析，我们将评估该算法在不同场景下的性能指标，并对其中存在问题提出改进方向。
1.2 结构概述本文共分为五个部分组成：•引言：介绍本文撰写目的、研究背景以及多级反馈队列调度算法在进程控制中的重要性。
•多级反馈队列调度算法：详细介绍多级反馈队列调度算法的基本原理、设计思路和算法流程图。
•C语言实现模拟进程控制：描述C语言中如何定义数据结构以及实现进程的创建、销毁以及调度和执行过程。
•实验结果与分析：介绍实验环境并展示实验结果，对结果进行分析和讨论。
•结论与展望：总结本文的研究成果，并提出该算法在应用过程中存在的问题以及改进方向。
通过以上结构安排，我们将全面深入地探讨多级反馈队列调度算法在模拟进程控制中的应用。
1.3 目的本文旨在通过使用C语言实现多级反馈队列调度算法，模拟进程控制过程。
通过对该算法进行分析和实验，目标如下：1.探讨多级反馈队列调度算法在不同场景下的优劣势，并对其性能指标进行评估。
进程调度实验报告源码
一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。
实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。
二、实验环境操作系统：Linux编程语言：C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法：FIFO（先进先出）、时间片轮转法、多级反馈队列调度算法。
2. 进程调度程序设计进程调度程序主要由以下部分组成：（1）进程控制块（PCB）PCB用于描述进程的基本信息，包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。
（2）就绪队列就绪队列用于存储处于就绪状态的进程，按照进程的优先级或到达时间进行排序。
（3）进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行，并将CPU分配给该进程。
（4）进程执行函数进程执行函数负责模拟进程的执行过程，包括进程的创建、执行、结束等。
四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明，FIFO调度算法按照进程的到达时间进行调度，可能导致短作业等待时间长，效率较低。
★多级反馈队列调度算法_实例
Feedback (q=1)
Time=7~9 RQ0=
RQ1=
RQ2=
A
B
C
Running=B and finished
64
Feedback (q=2i)
Time=0 RQ0= A
RQ1=
RQ2=
A
B
C
当一个进程第一次进入系统时，它被放置在RQ0，当它第一次被 抢占后并返回就绪状态时，它被放置在RQ1。在随后的时间里， 每当它被抢占时，它被降级到下一个低优先级队列中。一个短进 程很快会执行完，不会在就绪队列中降很多级。
A
B
C
q=21
Running=C and finished
74
Feedback (q=2i)
Time=7~9
RQ0=
RQ1=
RQ2=
A
B
C
q=21
Running=B and finished
75
Feedback
低级就绪队列
超过时间片
选中,时间片500ms
等待其 启动其他外设 他外设
运行
启动磁盘磁带
Time=3 RQ0= RQ1= A RQ2=
A
Feedback (q=2i)
B
C
69
Feedback (q=2i)
Time=3~4 RQ0=
RQ1= B
RQ2=
A
B
C
Running=A and finished
70
Time=4 RQ0= C RQ1= B RQ2=
A Running=A
Feedback (q=2i)
Time=4~5 RQ0=
RQ1= B
基于反馈(Feed Back,FB)排队算法的CPU调度的模拟实现
JLU《操作系统》课程设计[基于反馈（Feed Back，FB）排队算法的CPU调度的模拟实现]算法设计：多级反馈队列调度算法，不必事先知道各进程所需的进程时间，而且还可以满足各种类型进程的需要，因而它是目前被公认的一种较好的进程调度算法。
在采用多级反馈队列调度算法的系统中，调度算法的实施过程如下：1．设置多个就绪队列，并为各个队列赋予不同的优先级。
第一个队列的优先权最高，第二个的次之，其余各队列的优先权逐个降低。
该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。
例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第I+1个队列的时间片要比第I个队列的时间片长一倍。
2．一个新进程进入内存后，首先将它放在第一队列的末尾，按FCFS原则排队等待调度。
当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统，如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业（进程）从第一队列依次降到第n队列后，在第n队列中便采取按时间片轮转的方式进行。
3．仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1~（I-1）队列均空时，才会调度第I队列中为某进程服务时，又有新进程进入优先权较高的队列（第1~（I-1）中的任何一个队列），则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第I队列的末尾，把处理机分配给新到的高优先权进程。
任务分工及各分工实现方法：组长学号及姓名：分工：一直以来担任组长，要做的事很多，既要给组员分排任务，安排每个人的在课程设计要完成的任务，又要协调各个之间的分歧与合作，尽量融合大家的各种想法，汇总好的建议，好的做法，达到我们组的团体合作精神，这样才能把课程设计做的更好。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
JLU《操作系统》课程设计[基于反馈（Feed Back，FB）排队算法的CPU调度的模拟实现]程序代码：// 223.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <STRING.H> //Definitions for memory and string functions.#include <CTYPE.H> //Defines the ctype macros.#include <MALLOC.H> //memory management functions and variables.#include <STDIO.H>#include <STDLIB.H>#include <IO.H> //Definitions for low level I/O functions.#include <PROCESS.H> //Symbols and structures for process management.#include <CONIO.H> //Direct MSDOS console input/output.#include <WINDOWS.H>#include <TIME.H> // Struct and function declarations for dealing with time. #include <DOS.H> //Defines structs, unions, macros, and functions for dealing //with MSDOS and the Intel iAPX86 microprocessor family.// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2//////////////////////////////////////////typedef int Status; //指定用Status和Boolean代表int类型typedef int Boolean;//////////////////////////////////////////typedef struct QNode{char name[5];int time;int timeType;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear; // 队尾指针}LinkQueue;int count=0; //时间计数变量LinkQueue qRun,qWait,qReady1,qReady2,qReady3,qReady4;//////////////////////////////////////////////////////////////////////////void menu1();void menu2();void gotoxy(int x,int y);void clrscr(void); //清屏函数void clreol(void); //在文本窗口中清除字符到行末void clreoscr(void); //clear end of screenStatus InitQueue(LinkQueue &Q);Status creatPro(LinkQueue &quePro);void dealTime();void runPro(void);void run();void wait();void wake();void endPro();////////////////////////////////////////////////////////////////////////////DOS界面坐标定位函数/////////////////////////////////////////////////////void gotoxy(int x,int y){CONSOLE_SCREEN_BUFFER_INFO csbiInfo; //variablendklaration HANDLE hConsoleOut;hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hConsoleOut,&csbiInfo);csbiInfo.dwCursorPosition.X = x; //cursorposition X koordinate festlegencsbiInfo.dwCursorPosition.Y = y; //cursorposition Y koordinate festlegenSetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition); //den cursor an die festgelegte koordinate setzen}Status InitQueue(LinkQueue &Q){ // 构造一个空队列Qif(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))exit(OVERFLOW);Q.front->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,char e[5],int proTime,int tType){ // 插入元素e为Q的新的队尾元素QueuePtr p;if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败exit(OVERFLOW);strcpy(p->name,e);p->time=proTime;p->timeType=tType;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}Status DeQueue(LinkQueue &Q,char e[5]){ // 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR QueuePtr p;if(Q.front==Q.rear)return ERROR;p=Q.front->next;strcpy(e,p->name);Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return OK;}Status QueueTraverse(LinkQueue &Q,int x,int y){QueuePtr p;p=Q.front->next;while(p){gotoxy(x,y);printf("%s",p->name);gotoxy(x,y+1);printf("%d",p->time);p=p->next;x+=6;}printf("\n");return OK;}void print(){if(qRun.front!=qRun.rear){QueueTraverse(qRun,17,5);}if(qWait.front!=qWait.rear){QueueTraverse(qWait,17,8);}if(qReady1.front!=qReady1.rear){QueueTraverse(qReady1,17,11);}if(qReady2.front!=qReady2.rear){QueueTraverse(qReady2,17,14);}if(qReady3.front!=qReady3.rear){QueueTraverse(qReady3,17,17);}if(qReady4.front!=qReady4.rear){QueueTraverse(qReady4,17,20);}}Status creatPro(LinkQueue &quePro){char proName[5];int proTime;QueuePtr p;b: gotoxy(22,3);printf("进程名: ");gotoxy(36,3);printf("所需时间: ");gotoxy(30,3);scanf("%s",&proName);gotoxy(46,3);scanf("%d",&proTime);if(proTime<=0){gotoxy(22,3);printf("信息提示: 输入时间错误!请按Enter键返回!");gotoxy(15,3); getchar();getchar();gotoxy(0,0);menu1();goto b;}getchar();if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败exit(OVERFLOW);strcpy(p->name,proName);p->time=proTime;p->timeType=10; //进入时间片为10的就绪队列,即优先级最高的就绪队列p->next=NULL;quePro.rear->next=p;quePro.rear=p;return OK;}void dealTime(){char e[5];int tType=qRun.front->next->timeType;++count;qRun.front->next->time--;if(qRun.front->next->time==0){DeQueue(qRun,e);runPro();count=0;}elseif(qRun.front->next->timeType==count){if(qRun.front->next->timeType==10)EnQueue(qReady2,qRun.front->next->name,qRun.front->next->time,tType+10); if(qRun.front->next->timeType==20)EnQueue(qReady3,qRun.front->next->name,qRun.front->next->time,tType+20);if(qRun.front->next->timeType==40)EnQueue(qReady4,qRun.front->next->name,qRun.front->next->time,80);if(qRun.front->next->timeType==80)EnQueue(qReady4,qRun.front->next->name,qRun.front->next->time,80);DeQueue(qRun,e);runPro();count=0;}}void runPro(void){char e[5];int pTime,f1=0,f2=0,f3=0,f4=0;if(qReady1.front!=qReady1.rear){pTime=qReady1.front->next->time;EnQueue(qRun,qReady1.front->next->name,pTime,qReady1.front->next->timeType);DeQueue(qReady1,e);f1=1; }else{if(qReady2.front!=qReady2.rear){pTime=qReady2.front->next->time;EnQueue(qRun,qReady2.front->next->name,pTime,qReady2.front->next->timeType); DeQueue(qReady2,e);f2=1;}else{if(qReady3.front!=qReady3.rear){pTime=qReady3.front->next->time;EnQueue(qRun,qReady3.front->next->name,pTime,qReady3.front->next->timeType);DeQueue(qReady3,e);f3=1;}else{if(qReady4.front!=qReady4.rear){pTime=qReady4.front->next->time;EnQueue(qRun,qReady4.front->next->name,pTime,qReady4.front->next->timeType);DeQueue(qReady4,e);f4=1;}}}}gotoxy(0,4);menu2();if(f1==0 && f2==0 && f3==0 && f4==0){gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无就绪进程,请输入其他功能选项!");}gotoxy(0,4);menu2();}void run(){if(qRun.front==qRun.rear)runPro();elsedealTime();}void endPro(){char e[5];if(qRun.front==qRun.rear){gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无运行进程,请按Enter键运行进程!");gotoxy(15,3);}else{DeQueue(qRun,e);gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:选择菜单功能或按Enter键执行进程!");gotoxy(0,4);menu2();print();} }void wait(){char e[5];if(qRun.front!=qRun.rear){EnQueue(qWait,qRun.front->next->name,qRun.front->next->time,qRun.front->next->timeType); DeQueue(qRun,e);gotoxy(0,4);menu2();print();gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!");} else{gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无运行进程,请输入其他功能选项!");}}void wake(){char e[5];if(qWait.front!=qWait.rear){EnQueue(qReady1,qWait.front->next->name,qWait.front->next->time,qWait.front->next->timeType );DeQueue(qWait,e);gotoxy(0,4);menu2();print();gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!");}else{gotoxy(0,0);menu1();gotoxy(22,3);printf("信息提示:无等待进程,请输入其他功能选项!");}}void menu1(){printf(" ┏━━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━┓\n");printf(" ┃ 1-> 创建进程┃2-> 撤销进程┃3-> 阻塞进程┃4-> 唤醒进程┃0->退出系统┃\n");printf(" ┣━━━━━━━╋━━━━━━┻━━━━━━┻━━━━━━┻━━━━━━┫\n");printf(" ┃菜单选择: ┃┃\n");}void menu2(){printf(" ┣━━━━━┳━┻┳━━┳━━┳━━┳━━┳━━┳━━┳━━┳━━┳━━┫\n");printf(" ┃Run: ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Wait: ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready1 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:10 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready2 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:20 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready3 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:40 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┣━━━━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━╋━━┫\n");printf(" ┃Ready4 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┃Time:80 ┃┃┃┃┃┃┃┃┃┃┃\n");printf(" ┗━━━━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┻━━┛\n");}void main(){char a=NULL;system("color 0B");InitQueue(qRun);InitQueue(qWait);InitQueue(qReady1);InitQueue(qReady2);InitQueue(qReady3);InitQueue(qReady4);menu1();menu2();gotoxy(15,3);scanf("%c",&a);while(1){gotoxy(0,0);menu1();switch(a){case '1':creatPro(qReady1);print();gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!");while(1){f: gotoxy(15,3);a=getchar();if(a=='\n'){gotoxy(22,3);printf("信息提示: 选择菜单功能或按Enter键执行进程!"); run();gotoxy(0,4);menu2();print();}elsebreak;}getchar();break;case '2':endPro();goto f;break;case '3':wait(); goto f; print(); break;case '4':wake(); goto f; print(); break;case '0': gotoxy(22,3); exit(0); break;default:gotoxy(22,3);printf("信息提示: 输入错误!请选择正确的菜单功能选项!"); goto f;}print();}}。