系统平台实验5-进程调度
实验5 进程调度
实验
实验目的
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。
预习1．实验指导书 Nhomakorabea实验内容及要求
用高级语言模拟实现进程调度，完成下列指标：
③在优先数算法中，优先数可以先取值为98，进程每执行一次，优先数减3，CPU时间片数加1，进程还需要的时间片数减1。在轮转算法中，采用固定时间片。
④对于遇到优先数一致的情况，采用FIFO策略解决。
实验结果（可续页）
（续前页）
后记
①设计进程控制块PCB表结构，分别适用于优先数调度算法和循环轮转调度算法。
②建立进程就绪队列。对两种不同算法编制入链子程序。
③编制两种进程调度算法：1）优先数调度；2）循环轮转调度
实验提示
①本程序用两种算法对五个进程进行调度，每个进程可有三个状态（如就绪、执行、结束），并假设初始状态为就绪状态。
②为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
计算机操作系统进程调度实验报告
计算机操作系统进程调度实验报告实验报告：计算机操作系统进程调度1.实验背景与目的计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。
进程调度作为操作系统的重要功能之一，主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。
本实验旨在通过实践学习进程调度的原理和实现细节，加深对操作系统的理解。
2.实验原理与步骤（1）实验原理：进程调度的目标是充分利用计算机资源，提高系统的吞吐率和响应时间。
常用的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。
在本实验中，我们将实现时间片轮转调度算法，并对比不同算法的性能差异。
（2）实验步骤：1）设计进程数据结构：创建进程控制块（PCB）结构体，包含进程的标识符、到达时间、服务时间、剩余时间、等待时间等信息。
2）生成进程：根据指定的进程个数和服务时间范围，生成随机的进程并初始化进程控制块。
3）时间片轮转调度算法：根据时间片大小，按照轮转调度的方式进行进程调度。
4）性能评估：通过记录进程的等待时间和周转时间，比较不同调度算法的性能差异。
3.实验结果与分析通过实验我们生成了10个进程，并使用时间片大小为2进行轮转调度。
下表列出了各个进程的信息及调度结果。
进程到达时间服务时间剩余时间等待时间周转时间P108068P214004P3291310P4350115P542032P6570147P763063P8761714P981071P1093104从实验结果可以看出，时间片轮转调度算法相对公平地分配了CPU给各个进程，减少了等待时间和周转时间。
但是，对于长时间服务的进程，可能出现饥饿问题，即一些耗时较长的进程无法得到充分的CPU时间。
与时间片轮转算法相比，先来先服务（FCFS）算法对于短作业具有更好的响应时间，但可能导致长作业等待时间过长。
最短作业优先（SJF）算法能够最大化短作业的优先级，提高整体性能。
4.实验总结与体会本次实验通过实践了解了进程调度的原理与实现细节，加深了对操作系统的理解。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。
在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。
这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。
2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后，它将被挂起，等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。
操作系统-实验五-进程调度与算法模拟-实验报告
计算机与信息工程学院实验报告一、实验内容设计一个按优先数调度算法实现处理器调度的程序。
(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪8080”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
本实验由于为了检查的方便，优先数和运行时间采用下表中的数值。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志K1K2K3K4K5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
进程调度实验报告
进程调度实验报告这篇文章将讨论进程调度的相关实验及其结果。
进程调度是指计算机在多任务环境下对进程进行管理和调度，以便最大化系统的效率和可靠性。
在进程调度实验中，我们使用了Linux操作系统，并编写了一段程序来模拟具有多个进程的计算机系统。
我们首先定义了三个不同类型的进程：I/O Bound进程、CPU Bound进程和Interactive进程。
I/O Bound进程是一个需要从磁盘读取数据并进行处理的进程，CPU Bound进程则是一个需要使用CPU来完成复杂计算的进程，而Interactive进程是用户与系统交互的进程。
实验中，我们使用了三个不同的进程调度算法：Round Robin、先来先服务（FCFS）和最短作业优先（SJF）。
Round Robin是最简单的进程调度算法，它会将CPU时间分配给每个进程一段时间，然后切换到下一个进程。
FCFS根据队列中进程的顺序分配CPU时间。
SJF则是根据进程执行所需时间的长度进行调度的。
在我们的实验中，我们评估了每个算法的性能，并得出了以下结论：Round Robin算法的结果最好。
我们发现这种算法的表现非常良好，因为它能在繁忙的计算机系统中平均分配CPU时间，并避免长时间运行的进程占用计算机资源。
FCFS算法的性能很糟糕。
我们发现在FCFS算法中，长时间运行的进程会占用系统资源，而短时间运行的进程则需要等待很久才能获得CPU时间。
这样会导致整个计算机系统的效率下降。
SJF算法表现一般。
我们发现，在繁忙的系统中，SJF算法会基于当前进程的下一步行动来调度进程。
但是，如果多个进程具有相似的执行时间，并且它们需要同时运行，则存在一定的竞争和时间分配的缺陷。
总体来说，进程调度算法是计算机系统中非常重要的一部分，因为它会直接影响系统的效率和可靠性。
在我们的实验中，我们发现Round Robin算法是最好的选择，它能够抵消系统中不同进程需要不同时间的差异，确保每个进程都能获得相应的时间来完成任务。
实验进程调度的实验报告
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。
1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。
2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。
3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。
4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。
五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。
b. SJF算法：优先调度运行时间最短的进程。
c. 优先级调度算法：根据进程的优先级进行调度。
d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。
4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。
b. 循环执行调度算法，将CPU分配给就绪队列中的进程。
c. 更新进程状态，统计进程执行时间、等待时间等指标。
d. 当进程完成时，将其移至完成队列。
六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。
2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述：进程调度是操作系统中一个重要的组成部分，它负责决定在多个进程同时运行时，每个进程分配到的CPU时间片以及切换进程的时机。
合理的进程调度算法能够提高系统的性能和资源利用率，因此对进程调度的研究和优化具有重要意义。
1. 背景介绍进程调度是操作系统中的一个关键任务，它负责管理和控制多个进程的执行顺序，以实现对CPU的合理分配。
在多道程序设计环境下，进程调度的作用尤为重要。
进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法2.1 先来先服务（FCFS）先来先服务是最简单的调度算法之一，它按照进程到达的先后顺序进行调度，即先到达的进程先执行，直到该进程执行完成或者发生I/O操作。
FCFS算法的优点是公平且易于实现，但是它无法适应不同进程的执行时间差异，可能导致长作业效应。
2.2 最短作业优先（SJF）最短作业优先调度算法是根据进程的执行时间长度来进行调度，执行时间越短的进程越优先执行。
SJF算法能够最大程度地减少平均等待时间，但是它需要预先知道进程的执行时间，这在实际应用中往往是不可行的。
2.3 时间片轮转（RR）时间片轮转是一种经典的调度算法，它将CPU的执行时间划分为若干个时间片，每个进程在一个时间片内执行，如果时间片用完还没有执行完，则将该进程放入就绪队列的末尾，继续执行下一个进程。
RR算法能够保证每个进程都能获得公平的CPU时间，但是对于长时间执行的进程，会导致较大的上下文切换开销。
3. 实验设计与结果分析为了评估不同进程调度算法的性能，我们设计了一系列实验。
首先，我们使用不同的进程到达时间和执行时间生成一组测试数据。
然后，分别使用FCFS、SJF和RR算法进行调度，并记录每个进程的等待时间和周转时间。
最后，我们对实验结果进行分析。
实验结果显示，FCFS算法对于执行时间较长的进程会出现较长的平均等待时间，而SJF算法能够有效减少平均等待时间。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究，探究不同调度算法对系统性能的影响，进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）和轮转调度（RR），并通过模拟不同进程的到达时间和执行时间，分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例：确定不同进程的到达时间和执行时间，以及不同调度算法的时间片大小。
2. 模拟执行：根据设计的实验用例，使用模拟工具模拟不同调度算法的执行过程，并记录每个进程的执行情况和系统的运行情况。
3. 数据分析：根据实验结果，对比不同调度算法的平均等待时间、平均周转时间等指标，分析各算法的优缺点。
四、实验结果
通过实验比较，得出以下结论：
1. 先来先服务（FCFS）算法：适用于执行时间较短的进程，但容易导致长作业等待时间过长。
2. 最短作业优先（SJF）算法：能够最大程度地减少平均等待时间和平均周转时间，但无法处理长作业优先的情况。
3. 轮转调度（RR）算法：能够保证每个进程都能及时得到执行，但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果，不同的进程调度算法适用于不同的场景。
在实际应用中，需要根据系统的实际情况和需求选择合适的调度算法，以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验，加深了对进程调度算法的理解，同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验，能够为进程调度算法的研究和应用提供一定的参考和借鉴。
操作系统进程调度实验报告
操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。
进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。
本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。
一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。
二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。
三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。
FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。
这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。
2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。
一个进程通常包含进程ID、到达时间、执行时间等信息。
我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。
具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。
然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。
4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。
可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。
通过比较不同调度算法的指标，可以得出不同算法的优缺点。
四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。
实验五进程调度
实验五:进程调度实验目的：实现先来先服务FCFS、短作业优先SJF以及时间片轮转调度算法。
实验内容：①实现FCFS算法：根据进程的到达时间的先后次序来完成对若干进程的调度。
②实现SJF算法：根据当前时间已经到达进程的需要运行时间选取其中时间最小的进程最先运行。
③实现时间片轮转算法：首先要求确定时间片的大小，依据进程的到达时间依次加入队列，每次分配一个时间片大小的时间，如果没有完成参与下一次的竞争，当最后需要一个小于等于时间片的时间时本进程完成，同时退出队列。
④计算每种算法调度后，系统的平均周转时间和平均带权周转时间。
算法实现：[cpp]view plaincopy1.void FCFS()2.{3.int i;4.float sumT = 0.0;5.float sumW = 0.0;6.float last ;7. process[0].start = process[0].arrive;8. process[0].finish = process[0].start + process[0].service;9.10. last = process[0].finish;11.12. i = 1;13.while(i != N)14. {15.if(process[i].arrive > last)16. last = process[i].arrive;17. process[i].start = last;18. process[i].finish = last + process[i].service;19. last += process[i].service;20. i++;21. }22.23.for(i = 0 ; i < N; i++)24. {25. process[i].T = process[i].finish - process[i].arrive;26. process[i].W = process[i].T / (float)process[i].service;27. sumT += process[i].T;28. sumW += process[i].W;29. }30. FCFS_T = sumT / N;31. FCFS_W = sumW / N;32.}33.34.35.int getmin(float t)36.{37.int i;38.int addr = -1;39.float min=10000.0;40.41.for(i = 0 ; i < N ; i++)42. {43.if(process[i].state == 0 && process[i].service < min44. && process[i].arrive <= t)45. {46. addr = i;47. min = process[i].service;48. }49. }50.51. process[addr].finish = t + process[addr].service;52.53.return addr;54.}55.void SJF()56.{57.int i;58.float sumT = 0.0;59.float sumW = 0.0;60.61. process[0].finish = process[0].arrive + process[0].service;62. process[0].state = 1;63.64.int addr = 0;65.int sign = 0;66.float last = process[0].finish;67.68.while(sign != N-1)69. {70. addr = getmin(last);71.if(addr == -1)72. {73. last = process[getmin(1000)].arrive;74.continue;75. }76. process[addr].start = last;77. process[addr].state = 1;78. last = process[addr].finish;79. sign++;80. }81.82.for(i = 0 ; i < N; i++)83. {84. process[i].T = process[i].finish - process[i].arrive;85. process[i].W = process[i].T / (float)process[i].service;86. sumT += process[i].T;87. sumW += process[i].W;88. }89.90. SJF_T = sumT / N;91. SJF_W = sumW / N;92.}93.94.void RR()95.{96.int i = 0;97.int j;98.int t = process[0].arrive;99.float sumT = 0.0;100.float sumW = 0.0;101.for(j = 0 ; j < N ; j++)102. {103. process[j].state = 0;104. process[j].start = -1;105. process[j].left = process[j].service;106. }107. process[0].start = t;108.while(1)109. {110.for(j = 0 ; j < N ; j++)111.if(process[(i+j)% N].state == 0 && t >= process[(i+ j)% N].arrive)112.break;113. i = (i+j)% N;114.115.if( process[i].state == 1)116. {117.break;118. }119.120.if(process[i].start == -1)121. process[i].start = t;122.123.for(j = 0 ; j < min(process[i].left,q) ; j++)124. cout <<process[i].name;125.if(process[i].left > q)126. {127. t += q;128. process[i].left -= q;129. }130.else131. {132. t += process[i].left;133. process[i].left = 0;134. process[i].finish = t;135. process[i].state = 1;136. }137. i = (++i) %N;138. }139.140.for(i = 0 ; i < N ; i++)141. {142. process[i].T = process[i].finish - process[i].arrive; 143. process[i].W = process[i].T / (float)process[i].service; 144. sumT += process[i].T;145. sumW += process[i].W;146. }147.148. RR_T = sumT / N;149. RR_W = sumW / N;150.}。
操作系统实验报告-进程调度实验
进程调度实验一．实验目的及要求：进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
二 . 实验环境：操作系统：Windows XP编译环境：Visual C++ 6.0三．算法描述进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
四. 实验步骤：1.、进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间。
2、程序源码结构：struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort(){…} /* 建立对进程进行优先级排列函数*/ check(){…} /* 建立进程查看函数*/input(){…} /* 建立进程控制块函数*/main() /*主函数*/{...input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n resume......");ch=getchar();}printf("\n\n finished.\n");ch=getchar();}3.、实验截图：简单轮转法4、实验结果的分析及说明在操作系统中，由于进程总数多于处理机，它们必然竞争处理机。
实验5-进程调度
实验5 进程调度一、实验目的（1）加深对进程概念的理解，明确进程与程序的区别。
（2）深入了解系统如何组织进程，创建进程。
（3）进一步认识如何实现处理及调度。
二、实验内容1、观察进程状态（1）输入ps命令，观察用户自己的进程状态（2）输入ps-e命令，显示系统中运行的所有进程，包括系统进程和用户进程（3）输入ps-f命令，可以得到进程更详细的信息请思考：为什么ps命令本身也列进来了？ps的父进程是谁？因为ps命令也是一个进程。
而ps命令的PPID为9481，而PID为9481的CMD为-bash,所以ps的父进程为bash。
（4）输入ps-el命令，得到所有进程的附加属性长列表信息请观察：系统进程和用户进程谁的优先级比较高？系统进程的优先级比较高。
2、进程控制（1）后台控制（2）作业控制输入命令$ sleep 60 和$ sleep 30，系统将睡眠30秒和60秒再运行，但是按下Ctrl+z后会停止其睡眠操作，当使用命令bg 1时sleep 60的命令就在后台在运行了，使用fg 2的命令时sleep 30的命令就在前台运行了，输入jobs 命令查看到得所有所有子进程状态，显示的是已经完成的进程sleep 60命令。
3、父进程与子进程(1)在执行本程序时，因为没有wait(NULL);,所以输出结果先从father开始,且执行for(j=0;j<100000;j++);过程中由于等待时间的缘故，有其他进程相应，所以在此期间会有输出结果son和输出结果daughter交替出现的现象。
(2)由于本程序中有wait(NULL);语句,所以此时要等待子进程结束后才执行,因此输出结果总是先从daughter开始，而且必须是等daughter这一结果输出完之后再依次按子父进程的顺序执行，所以此后可以看到输出结果son和输出结果daughter按顺序输出的结果。
4、进程调度模拟算法学号尾数是11，所以是case2：编写最短进程算法程序代码如下：//最短进程优先：先调度所需运行时间最短的进程public void ShortestFirstSchedule(){for (int i = 0; i < waitingList.size() - 1; i++) {for (int j = 0; j < waitingList.size() - i - 1; j++) { Process proc1 = waitingList.get(j);Process proc2 = waitingList.get(j+1);if (proc1.needtime > proc2.needtime) {waitingList.set(j,proc2);waitingList.set(j + 1,proc1);}}}FIFOSchedule();}final int TIME_SLICE=2;运行结果如下：三、实验心得本次实验是分两次进行的，第一次的实验较为简单，主要是父进程与子进程那部分较为复杂，而第二次实验内容相对来说比较难，因为我的是case2进程最短算法，所以还是比较简单的。
《操作系统》上机实验报告—进程调度
专业和班级
成绩
姓名
学号
课程名称
操作系统
实验名称
进程调度
实
验
目
的
和
要
求
1.进程调度是处理机管理的核心内容。
2.本实验要求用C语言编写和调试一个简单的进程调度程序。
3.通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。
理
论
pcb *p;
pcb *r;
p=get_process();
int cpu=0;
r=p;
while(!process_finish(p)){
cpu+=2;
cpu_round(r);
r=get_next(r,p);
cout<<"运行次数"<<cpu<<endl;
display_round(p);
set_state(p);
if(q->process!=finish)
{t=q;
i=q->priority;
}
q=q->next;
}
t->needtime-=1;
t->priority-=3;
if(t->needtime==0)
t->process=finish;
t->cputime+=1;
}
void priority_cal() //优先级调度算法
if(t==NULL)
{
t=head;
while (t->next!=k && t->process==finish)
操作系统实验之进程调度报告
实验一:进程调度一、实习内容1．模拟批处理多道操作系统的进程调度；2．模拟实现同步机构避免并发进程执行时可能与时间相关的错误；二、实习目的进程调度时进程管理的主要内容之一，通过设计，编制，调试一个简单的进程调度模拟系统，对进程调度，进程运行状态变换及PV操作加深理解和掌握。
三、实习题目采用剥夺式优先算法，对三个进程进行模拟调度模拟PV操作同步机构，用PV操作解决进程进入临界区的问题。
【提示】（1）对三个进程进行模拟调度，对各进程的优先数静态设置，P1,P2,P3三个进程的优先数为1，2，3，并指定P1的优先数最高，P3的优先数最低，每个进程都处于执行态“e”，就绪态“r”，等待态“w”三种状态之一，并假定初始态为“r”。
（2）每一个进程用一个PCB表，PCB表的内容根据具体情况设置，该系统在运行过程中能显示或打印各进程和参数的变化情况，以便观察各进程的调度。
（3）在完成必要的初始化后，便进入进程调度程序，首先由P1进入执行，当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时，转进程调度。
（4）在进入临界区前后，调PV操作。
（5）如果被唤醒的进程优先数高于现有执行的进程，则剥夺现行进程的执行权。
（6）当三个进程都处于等待状态时，本模拟系统退出执行。
四、示例1.数据结构：（1）进程控制块PCBstruct{int id;char status;int priority;int waiter1;}（2）信号量struct{int value;int waiter2;}sem[2]（3）现场保护栈stackchar stack[11][4]每个进程都有一个大小为10个字的现场保护栈，用来保护被中断时的断点地址等信息。
（4）全局变量int i;用以模拟一个通用寄存器char addr;用以模拟程序计数器int m1,m2;为系统设置的公用数据被三个进程共享使用。
五、程序框图：六、程序说明：本程序是用C语言编写，模拟三个进程的运行情况，过程在运行中要调用P操作申请信号量，如果该过程得到其申请的信号量，就继续运行，否则P操作阻塞该申请过程的运行，并将过程置为所申请信号量的等待者，如果已有其它过程在等待同一信号量则将该申请过程排在所有等待进程之后。
操作系统实验进程调度程序设计
操作系统实验进程调度程序设计实验目的：1.了解进程调度的原理和实现方式；2.掌握操作系统中进程调度算法的设计和实现方法；3.实现一个简单的进程调度程序，模拟不同的调度算法。
实验内容：在操作系统中，进程调度是一项重要的任务。
它负责决定哪些进程可以运行，以及在什么时间运行。
进程调度的主要目标是提高计算机系统的资源利用率和吞吐量，以及减少用户的响应时间。
本次实验的目标是设计一个简单的进程调度程序，并实现不同的调度算法。
你需要完成以下任务：1. 了解调度算法的基本概念和原理，如先来先服务（FCFS）、最短进程优先（SJF）、优先级调度（Priority Scheduling）、时间片轮转（Round Robin）等；2. 设计一个进程控制块（Process Control Block, PCB），用于存储进程的相关信息，包括进程的标识符、优先级、到达时间、执行时间等；3.实现以上调度算法中的任意一种。
你可以选择自己感兴趣或熟悉的调度算法进行实现。
如果你不确定，可以选择先来先服务（FCFS）算法，这是最简单的调度算法之一；4.编写测试程序，模拟多个进程的到达和执行过程。
你可以根据需要设置不同的进程到达时间和执行时间，并观察不同调度算法下的执行效果。
实验步骤：1.了解调度算法的原理和实现方式。
可以通过查阅相关教材、资料或网络资源来获得更多信息；2. 设计进程控制块（Process Control Block, PCB），其中包括进程的标识符、优先级、到达时间、执行时间等信息；3.根据选择的调度算法，编写相应的调度程序。
你可以选择使用C、C++或其他编程语言来实现；4.编写测试程序，模拟多个进程的到达和执行过程。
可以通过使用随机数生成器来模拟进程到达时间和执行时间；5.运行测试程序，观察不同调度算法下的执行效果。
可以比较各个算法的平均周转时间、平均等待时间等指标，并分析结果；6.根据需要进行调整和优化，再次运行测试程序，并观察结果；7.总结实验过程和结果，撰写实验报告。
实验五：进程调度
实验五：进程调度一、实验目的1、理解进程调度的过程。
2、掌握各种进程调度算法的实现方法3、通过实验比较各种进程调度算法的优劣。
进程调度算法是系统管理进程调度，提高系统性能的重要手段。
通过本次实验理解进程调度的机制，在模拟实现先来先服务FCFS、轮转RR（q=1）、最短进程优先SPN、最短剩余时间SRT、最高响应比优先HRRN算法的基础上，比较各种进程调度算法的效率和优劣，从而了解系统进程调度的实现过程。
二、实验内容随机给出一个进程调度实例，如：进程到达时间服务时间A 0 3B 2 6C 4 4D 6 5E 8 2模拟进程调度，给出按照算法先来先服务FCFS、轮转RR（q=1）、最短进程优先SPN、最短剩余时间SRT、最高响应比优先HRRN进行调度各进程的完成时间、周转时间、响应比的值。
三、实验环境PC + Linux Red Hat操作系统GCC四、实验原理及实验思路1、FCFS 先来先服务也可以称为是FIFO先进先出。
此策略是当前正在运行的进程停止执行时，选择在就绪队列中存在时间最长的进程运行。
这种策略执行长进程比执行短进程更好。
2、轮转这种策略是以一个周期性间隔产生时钟中断，当中断发生时，当前正在运行的进程被置于就绪队列中，然后基于FCFS策略选择下一个就绪作业运行，目的是为了减少在FCFS策略下短作业的不利情况。
3、SPN最短进程优先这种策略是下一次选择所需处理时间最短的进程。
是非抢占策略，目的也是为减少FCFS策略对长进程的偏向。
4、SRT最短剩余时间这种策略下调度器总是选择预期剩余时间最短的进程。
是抢占策略。
5、HRRN最高响应比优先当当前进程完成或被阻塞时，选择响应比R最大的就绪进程，R=(w+s)/s 其中w: 等待处理器的时间，s:期待的服务时间。
这样长进程被饿死的可能性下降。
五、流程图六、源代码#include <stdio.h>#include <math.h>void FCFS(float Atime[],float Stime[]); void SJF(float Atime[],float Stime[]); void RR(float Atime[],float Stime[]); void HRN(float Atime[],float Stime[]); main(){char c;int i;float Atime[5]={0,2,4,6,8};float Stime[5]={3,6,4,5,2};for(i=0;i<5;i++)printf("%5.2f ",Atime[i]);printf("\n");for(i=0;i<5;i++)printf("%5.2f ",Stime[i]);printf("\n");scanf("%c",&c);switch(c){ case 'F':FCFS(Atime,Stime);break; case 'S':SJF(Atime,Stime);break; case 'R':RR(Atime,Stime);break; case 'H':HRN(Atime,Stime);break; default:printf("error");}}void FCFS(float Atime[],float Stime[]) {float Ctime[5];float ZZtime[5];float DQtime[5];int i;Ctime[0]=Stime[0];for(i=1;i<5;i++)Ctime[i]=Stime[i]+Ctime[i-1];for(i=0;i<5;i++)printf("%5.2f ",Ctime[i]);printf("\n");for(i=0;i<5;i++){ZZtime[i]=Ctime[i]-Atime[i];printf("\n");for(i=0;i<5;i++){DQtime[i]=ZZtime[i]/Stime[i];printf("%5.2f ",DQtime[i]);}printf("\n");}void SJF(float Atime[],float Stime[]){float Ctime[5];float ZZtime[5];float DQtime[5];int i,j;float m,n;Ctime[0]=Stime[0];ZZtime[0]=Ctime[0]-Atime[0];DQtime[0]=ZZtime[0]/Stime[0];for(j=1;j<=3;j++)for(i=1;i<=4-j;i++)if(Stime[i]>Stime[i+1]){m=Stime[i];Stime[i]=Stime[i+1];Stime[i+1]=m;n=Atime[i];Atime[i]=Atime[i+1];Atime[i+1]=n; }for(i=0;i<5;i++)printf("%5.2f ",Atime[i]);printf("\n");for(i=0;i<5;i++)printf("%5.2f ",Stime[i]);printf("\n");for(i=1;i<5;i++){Ctime[i]=Stime[i]+Ctime[i-1];}for(i=0;i<5;i++)printf("%5.2f ",Ctime[i]);printf("\n");for(i=1;i<5;i++)ZZtime[i]=Ctime[i]-Atime[i];for(i=0;i<5;i++)printf("\n");for(i=1;i<5;i++)DQtime[i]=ZZtime[i]/Stime[i];for(i=0;i<5;i++)printf("%5.2f ",DQtime[i]);printf("\n");}void RR(float Atime[],float Stime[]) {float Ctime[5];float ZZtime[5];float DQtime[5];int i,j,h,f,q;float t[5],k;scanf("%d",&q);for(i=0;i<5;i++){if(q<Stime[i]){for(j=0;j<5;j++){k=Stime[j]/q-1;t[j]=Atime[j]+k*(5/q)+1;for(h=0;h<5;h++){if(Stime[h]<k){f=h;}elseCtime[j]=t[j];}Ctime[j]=t[j]-(k-Stime[f]);}}else{Ctime[0]=Stime[0];for(i=1;i<5;i++)Ctime[i]=Stime[i]+Ctime[i-1];}for(i=0;i<5;i++)ZZtime[i]=Ctime[i]-Atime[i];for(i=0;i<5;i++)DQtime[i]=ZZtime[i]/Stime[i];for(i=0;i<5;i++)printf("%5.2f ",Ctime[i]);printf("\n");for(i=0;i<5;i++)printf("%5.2f ",ZZtime[i]);printf("\n");for(i=0;i<5;i++)printf("%5.2f ",DQtime[i]);printf("\n");}}void HRN(float Atime[],float Stime[]){float Ctime[5];float ZZtime[5];float DQtime[5];int i,j,t=1;float m,n,k,f;Ctime[0]=Stime[0];ZZtime[0]=Ctime[0]-Atime[0];DQtime[0]=ZZtime[0]/Stime[0];for(j=1;j<=3-t;j++)for(i=1;i<=4-j-t;i++){k=Ctime[j-1]-Atime[i];f=Ctime[j-1]-Atime[i+1];if(k/Stime[i]<f/Stime[i+1]){m=Stime[i];Stime[i]=Stime[i+1];Stime[i+1]=m;n=Atime[i];Atime[i]=Atime[i+1];Atime[i+1]=n;t++;}}for(i=0;i<5;i++)printf("%5.2f ",Atime[i]);printf("\n");for(i=0;i<5;i++)printf("%5.2f ",Stime[i]);printf("\n");for(i=1;i<5;i++){Ctime[i]=Stime[i]+Ctime[i-1];}for(i=0;i<5;i++)printf("%5.2f ",Ctime[i]);printf("\n");for(i=1;i<5;i++)ZZtime[i]=Ctime[i]-Atime[i];for(i=0;i<5;i++)printf("%5.2f ",ZZtime[i]);printf("\n");for(i=1;i<5;i++)DQtime[i]=ZZtime[i]/Stime[i];for(i=0;i<5;i++)printf("%5.2f ",DQtime[i]);printf("\n");}七、运行结果及其分析当程序运行，打印出5个进程到达时间：0 2 4 6 8 和服务时间：3 6 4 5 2时，然后再输入要选择的调动服务算法F :FCFS S :SJF R :RR H :HRN 可得到不同的完成情况。
进程调度实验报告
进程调度实验报告引言：进程调度是操作系统中一个重要的概念，它决定了一个进程何时开始执行、何时暂停、何时唤醒等等。
一个良好的进程调度算法可以提高系统的效率和响应时间。
在这次实验中，我们将对不同的进程调度算法进行测试和对比分析，旨在探究不同算法对系统性能的影响。
实验步骤：1. 实验准备在实验开始前，我们需要准备一个充分复杂的测试环境，包括不同类型的进程、不同进程的优先级、进程执行时间等参数。
这些参数的设置将影响我们对不同调度算法的评估。
2. 先来先服务调度算法（FCFS）先来先服务调度算法是最简单的一种调度算法，按照进程到达CPU的顺序依次执行。
在这个实验中，我们首先对先来先服务调度算法进行测试。
结果显示，对于短时进程，FCFS算法效果较好，但在遇到长时进程时，会出现“饥饿”现象，易导致优先级较低的进程无法获得CPU时间。
3. 短作业优先调度算法（SJF）短作业优先调度算法根据进程执行时间的长短来进行调度。
在实验中，我们通过设置不同长度的进程来对SJF算法进行测试。
结果显示，SJF算法能够较好地避免“饥饿”现象，但如果长作业在一个时间片内到达，就会导致短作业等待时间过长。
4. 优先级调度算法（Priority）优先级调度算法通过为每个进程指定一个优先级来进行调度，优先级高的进程先执行。
在实验中，我们设置不同优先级的进程，测试Priority算法的效果。
结果显示，Priority算法能够合理地根据优先级分配CPU时间，但如果优先级的划分不合理，可能导致某些进程优先级一直很低，影响整体系统性能。
5. 时间片轮转调度算法（Round Robin）时间片轮转调度算法是一种较为公平的调度算法，每个进程被分配一个时间片，在时间片用完后，进程暂停执行，并被放置于“就绪队列”尾部，等待下一个时间片。
在测试中，我们可以通过设置不同的时间片长度来观察时间片轮转算法的效果。
结果显示，时间片轮转算法能够较好地平衡进程的等待时间和执行时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验5 进程调度一、实验目的通过本实验了解和掌握进程管理的相关知识，使学生（1）加深对进程概念的理解，明确进程和程序的区别。
（2）深入了解系统如何组织进程，创建进程。
（3）进一步认识如何实现处理机调度。
二、实验内容1. 观察进程状态（1）输入ps命令，观察用户自己的进程的状态说明：PID表示进程的标识号(ID)；TTY表示进程所在的控制终端；TIME表示该进程累计执行的时间，即占用CPU的时间，以hh:mm:ss表示；CMD表示该进程所对应的命令。
①每个进程都有唯一的PID号，并且每个进程的PID号都不相同。
如果用户在不同时间输入同一个命令，则它们的PID也不相同。
这是由于Linux命令是通过进程完成的。
在不同时间运行相同的命令，系统会建立不同的进程。
②不同进程的TTY标识符可以相同，表明这些进程都是在同一个终端上建立的。
③尽管用户注册进入系统已经有一段时间，而且输入命令也用去不少时间，但各进程只占用很少的CPU时间。
④用户输入的命令名就是相应的进程名，即：命令的执行是通过建立并运行相应的进程实现的。
（2）输入ps –e命令，显示系统中运行的所有进程，包括系统进程和用户进程。
说明：可以看到，进程数目一下子增多了。
这是因为系统中存在很多系统进程，也成为守护进程(daemon),它们不与某台终端或某个用户相关联。
系统进程不是由用户命令建立的进程，而是由系统创建的进程，专门用于执行系统管理和各种服务等功能，如进程的对换、终端的初启。
系统进程定期的执行系统任务并在这些任务之间睡眠。
对于系统进程，TTY字段上出现的字符是一个“？”。
你可能还会发现，系统进程的PID号相对来说都比较小。
（3）输入ps –f命令，可以得到进程更详细的信息。
其中：UUID表示建立该进程的用户注册名；PPID表示父进程的ID；C表示该进程最近使用CPU情况的统计；STIME表示启动进程的时间；CMD执行该进程的命令。
请思考：为什么ps命令本身也列进来了？ps的父进程是谁？（4）输入ps –el命令，得到所有进程的附加属性长列表信息可以看到进程的优先级(PRI)信息。
请观察：系统进程和用户进程谁的优先级比较高？进程的族系关系如何？（根据父进程ID推测）说明：0号进程是系统中第1个进程，它创建1号进程，1号进程创建各终端的注册进程、会话进程以及Shell进程，由shell进程为用户在终端上输入的命令创建相应的进程。
2. 进程控制（1）后台进程注册shell进程是用户执行的大多数命令（子进程）的父进程。
通常情况下在系统提示用户输入新的命令之前，shell要等待其子进程（前台进程）的结束。
用户可以让shell不必等待子进程结束就可以继续接受另外的命令，其方法就是把命令放入后台运行。
为了在后台运行一个命令，要在该命令行的末尾加上一个&字符，于是shell就立即返回提示符$。
例如，写一个运行耗时比较长的程序loop.c并编译运行。
$./loop &[1] 586$其中，[1]表示作业号，586是后台进程的PID号。
在命令中可以使用PID监控该后台进程。
例如：$ps –p 586说明：如果命令执行需要很长时间才能完成，那么就需要采用后台执行的方式。
但是，交互式程序不适合，例如vi。
当用户在后台运行一个命令式，应该使用重定向机制把该命令的输出定向到一个文件，否则，它会在无法预测的时候在屏幕上显现出来。
当后台进程终止时，shell将通知用户。
它只是简单地给出该子进程的作业号，并不显示其PID。
（2）作业控制●挂起进程：shell允许用户挂起正在运行的进程，可以把进程从后台移到前台或者从前台移到后台。
shell可以将当前正在运行的子进程挂起，并且告诉shell不用等待子进程终止。
当一个子进程被挂起的时候，屏幕上就显示了该进程作业号和命令名，如下所示：[1] + Stopped command例如，用户正在运行命令：$ man ls |more在没有全部显示完之前，按下Ctrl+Z组合键，在屏幕上就会看到：[1] + Stopped man ls |more●后台作业一旦用户挂起一个进程，就可以用bg命令在后台运行这个进程，例如：$ bg PID●前台作业使用fg命令，可以把一个后台运行的进程调度到前台运行，例如：$fg PID●显示作业状态使用jobs命令显示正在运行的所有子进程的状态，例如：$jobs●进程休眠使用sleep命令让当前进程休眠若干秒，该秒数由参数指定，例如：$sleep 60 &●综合练习1)输入以下命令：$ sleep 60$ sleep 302)现在按下Ctrl+Z组合键。
注意被停止的进程的号码，并且shell提示符会重新出现。
3)输入命令：$jobs查看各个子进程的状态。
4)使用bg命令，把睡眠60秒的sleep命令放在后台运行5)使用fg命令，把睡眠30秒的sleep命令放在前台运行6)当60秒的sleep命令完成后，运行jobs命令分析输出结果，它是你所期望的情况吗？3. 父进程与子进程阅读下面的源程序，完成实验任务。
#include<stdio.h>main(){int p1,p2,i,j;if(p1=fork()){//wait(NULL);for(i=0;i<10;i++){for(j=0;j<100000;j++);printf("father %d\n",i);}}else{if(p2=fork()){//wait(NULL);for(i=0;i<10;i++){for(j=0;j<100000;j++);printf("son %d\n",i);}}elsefor(i=0;i<10;i++){for(j=0;j<100000;j++);printf("daughter %d\n",i);}}}（1）读懂上面的程序，编译执行，观察结果。
多执行几次（至少10次以上），观察结果的不同变化，尽可能详细的描述执行结果，并分析为什么出现这样的情况。
（2）将上述程序中两句wait语句的注释去掉，重新编译执行，再运行10次以上，观察结果，并分析为什么出现这样的情况。
理解wait()系统调用的作用。
（3）模仿上述程序，编程使用fork()创建一个子进程，要求在父、子进程中显示出fork()的返回值以及父、子进程的唯一pid值。
编写程序后请自行运行和调试，并观察输出是否正确。
三、实验要求1. 完成上述实验内容中相应的实验任务。
2. 写出实验报告，包括：实验目的、实验内容及步骤、实验结果、心得体会等部分。
四、实验指导1. Linux下的系统调用所谓系统调用是指操作系统提供给用户程序调用的一组特殊接口，用户程序可以通过这组特殊接口来获得操作系统内核提供的服务。
例如用户可以通过进程控制块相关的系统调用来创建进程、实行进程管理等。
为什么用户程序不能直接访问系统内核提供的服务呢？这是由于在Linux中，为了更好的保护内和空间，将程序的运行空间分为内核空间和用户空间（也就是常称的内核态和用户态），它们运行在不同的级别上，在逻辑上是相互分离的。
因此，用户进程在通常情况下不允许访问内核数据，也无法使用内核数据，它们只能在用户空间操作用户数据，调用用户空间的函数。
但是在有些情况下，用户空间的进程需要获得一定的系统服务（调用内核空间程序），因此操作系统必须利用系统提供给用户的特殊接口——系统调用来规定用户进程进入内核空间的具体位置。
进行系统调用时，程序运行空间需要从用户空间进入内核空间，处理完后再返回用户空间。
下面介绍将在实验中用到的系统调用。
（1）fork()功能：创建一个新进程。
系统调用格式：pid=fork();参数定义：int fork()；fork()返回值的意义如下：●0 在子进程中，pid变量保存的fork()返回值为0，表示当前进程是子进程。
●>0 在父进程中，pid变量保存的fork()返回值为子进程的id值（进程唯一标识符）●-1 创建失败如果fork()调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork()被调用了一次，但返回了两次。
此时OS在内存中建立一个新进程，所建立的新进程是调用fork()父进程（parent process）的副本，称为子进程（child process）。
子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。
父进程与子进程并发执行。
（2）getpid()本函数的头文件为：#include <sys/types.h> /*提供类型pid-t的定义*/#include <unistd.h> /*提供函数的定义*/功能：用来得到进程唯一的pid号。
系统调用格式：pid-t getpid(void)（3）exec ()系列系统调用exec()系列，可以用于新程序的运行。
fork()只是将父进程的用户级上下文拷贝到新进程中，而exec系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。
exec()系列中的系统调用都完成相同的功能，它们把一个新的程序装入内存，用来改变调用进程的执行代码，从而形成新进程。
如果exec()调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id与调用进程相同。
exec()没有建立一个与调用进程并发的子进程，而是用新进程取代了原来的进程。
所以exec()调用成功后，没有任何的数据返回，这与fork()不同。
exec()系列系统调用在UNIX系统库unistd.h中，共有execl、execlp、execle、execv、execvp、execve六个，其基本功能相同，只是以不同的方式来给出参数。
一种是直接给出参数的指针，如：int execl(path, arg0[,arg1,…,argn],0)char *path, *arg0, *arg1,…,*argn;另一种是直接给出指向参数表的指针，如：int execv(path, argv)char *path, *argv[];（4）exec ()和fork()联合使用系统调用exec()和fork()联合使用能为程序开发提供有力支持。
用fork()建立子进程，然后在子进程中使用exec()，这样就实现了父进程和一个与它完全不同子进程的并发执行。
一般，wait、exec联合使用的模型为：int status；…if(fork()==0){…;execl(…);…;}wait(&status);（5）wait()等待子进程运行结束。