实验二Linux进程调度及用户管理系统
Linux2 调度进程
Linux2 调度进程在Fedora Core Linux系统中，允许多个进程并发执行。
但是，通常情况下，系统中的资源总是有限的，如果系统中并发执行的进程数量过多，就会造成系统的整体性能下降，尤其是当系统中存在黑客进程或者病毒进程时，甚至可能会造成系统瘫痪。
因而，有必要根据一定的策略对系统中的进程进行调度，例如，将可疑的进程终止，将不紧急的进程挂起或者降低其优先级等。
系统管理员或者普通用户都可以对进程进行调度，但是执行这种操作时要非常小心，因为有些进程是与系统运行相关联的，不能对它们有错误的调度。
可以使用如下所示的任一种方法进行进程调度：●在系统监视器的“进程”选项页中进行调度。
●在top命令的执行过程中使用交互命令进行调度。
●在命令行中直接执行各种调度进程的命令。
下面将介绍如何使用命令行命令调度进程。
1．更改进程的优先级在fedora系统中，各个进程都是具有特定的优先级的，系统在为某个进程分配CPU使用时间时是根据进程的优先级进行判定的。
有些进程比较重要，需要先执行，以提高整个程序的执行效率，而有些不太重要的进程，其优先级可以低一些。
通常情况下，大多数用户进程的优先级是相同的，但是可以使用Fedora提供的某些命令改变进程的优先级。
通过执行“ps -l”命令可以查看当前用户进程的优先级，如下所示。
PRI表示进程的优先级，它是由操作系统动态计算的，是实际的进程优先级；NI所表示的是请求进程执行优先级，它可由进程拥有者或者超级用户进行设置，NI会影响到实际的进程优先级。
下面介绍两个可以改变进程优先级的命令。
（1）nice命令格式：nice 【选项】命令功能：在启动进程时指定请求进程执行优先级。
该命令较常用的一个选项是“-n”，n值（即NI值）的范围是从-20到19。
-20代表最高的NI优先级，19代表最低的NI优先级。
如果没有该参数，将自动设置NI值为10。
默认情况下，只有超级用户才有权提高请求进程的优先级，而普通用户只能降低请求进程的优先级。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
实验二：Linux进程管理
姓名
学号
上机时间
实验
内容
在Linux系统中，进行进程启动、调度、监控和管理
实验
目的
1.能够借助Linux进程调度命令，在系统中设置计划任务
2.能够使用Linux中各种进程监控命令，对系统中的进程进行监控和管理实验 Nhomakorabea工具
1.VMware Workstation
2.Red Hat Enterprise Linux 5
实验步骤
1.进入模拟机，Red Hat Enterprise Linux 5进程启动
2.进程调度
3查看在线用户，其中
NAME：登录用户帐号LINE：登录使用的终端
TIME：登录时间IDLE：显示用户空闲时间
COMMENT：用户从什么地方登录的网络地址
W命令进程查看，显示当前用户正在进行的进程命令行
进行ps命令监控，分为-a和-aux操作，- a选项可查看当前所有用户的所有进程，- aux组合选项，可显示最详细的进程情况
进行top动态监控
关闭和强制关闭PID为177的程序进程，其中killalll为关闭所有进程
总结
通过本节实验，学习了在Linux系统中，进行进程启动、调度、监控和管理，以及各种命令行的运行、监控及管理。
进程调度实验报告
进程调度实验报告这篇文章将讨论进程调度的相关实验及其结果。
进程调度是指计算机在多任务环境下对进程进行管理和调度，以便最大化系统的效率和可靠性。
在进程调度实验中，我们使用了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算法是最好的选择，它能够抵消系统中不同进程需要不同时间的差异，确保每个进程都能获得相应的时间来完成任务。
Linux终端中的系统进程调度和管理命令
Linux终端中的系统进程调度和管理命令Linux操作系统作为一种开源的操作系统，具有高度的可定制性和灵活性。
在Linux终端中，系统进程调度和管理是非常重要的一部分。
本文将探讨Linux终端中常用的系统进程调度和管理命令。
一、进程调度命令1. ps命令ps命令用于查看当前系统的进程状态。
在终端中输入"ps"命令，即可列出当前运行的所有进程，并且提供各种详细信息，如进程ID （PID）、状态、CPU使用率等。
示例：```$ psPID TTY TIME CMD1 ? 00:00:01 init2 ? 00:00:00 kthreadd3 ? 00:00:00 migration/04 ? 00:00:00 ksoftirqd/0...```2. top命令top命令是一个实时的进程查看工具，用于查看当前系统的进程状态和系统资源的使用情况。
在终端中输入"top"命令，即可实时地显示进程列表和各个进程的资源占用情况。
示例：```$ toptop - 20:30:50 up 1 day, 1:35, 3 users, load average: 0.02, 0.02, 0.00 Tasks: 256 total, 1 running, 255 sleeping, 0 stopped, 0 zombie%Cpu(s): 0.2 us, 0.2 sy, 0.0 ni, 99.6 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 stKiB Mem : 4044080 total, 834456 free, 2679908 used, 532716 buff/cacheKiB Swap: 4194300 total, 0 free, 4194300 used. 1185820 avail Mem...```3. nice命令nice命令用于设置进程的优先级。
linux进程管理的实验报告
实验报告：Linux进程管理1. 引言本实验报告将详细介绍Linux系统中进程管理的相关知识和操作。
进程管理是操作系统中的一个重要组成部分，它负责控制和调度系统中运行的各个进程，确保系统资源的合理分配和进程的正常运行。
在本实验中，我们将通过一系列步骤来了解Linux系统中进程的创建、监控和控制。
2. 实验环境为了完成本实验，我们需要在一台运行Linux操作系统的计算机上进行操作。
本实验报告基于Ubuntu 20.04 LTS操作系统进行撰写，但是适用于大多数Linux 发行版。
3. 实验步骤步骤一：创建新进程在Linux系统中，可以通过fork()系统调用来创建新的进程。
以下是一个简单的示例代码：#include <stdio.h>#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {// 子进程逻辑printf("这是子进程\n");} else if (pid > 0) {// 父进程逻辑printf("这是父进程\n");} else {// 进程创建失败printf("进程创建失败\n");}return0;}步骤二：查看进程信息Linux系统提供了多种命令来查看系统中运行的进程信息。
以下是一些常用的命令：•ps：显示当前终端下的进程列表。
•top：实时显示进程的CPU、内存等资源占用情况。
•pstree：以树状结构显示进程的层次关系。
步骤三：杀死进程有时候我们需要终止一个运行中的进程，可以使用kill命令来发送终止信号给目标进程。
以下是一个示例：kill <PID>请将<PID>替换为目标进程的进程ID。
步骤四：进程优先级调整通过调整进程的优先级，可以影响进程在系统中的调度顺序。
在Linux系统中，可以使用nice命令来调整进程的优先级。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
Linux操作系统实验2-进程调度的操作
1.查看并创建用户的计划任务列表crontab文件；
1)查看crontab命令的帮助信息；
在终端下键入info crontab, 进入crontab帮助手册：
2)查看用户的计划任务列表；
查看特定用户的计划任务列表：
在终端下键入crontab -l -u duke 列出duke用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
查看当前用户的计划任务列表：
在终端下键入crontab -l 列出当前用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
2.通过crontab文件对调度进程的计划任务进行编排操作。
1)建立crontab文件；
在终端下键入crontab -e ，提示当前无crontab文件，选择编辑器并新建如下：进入VI编辑器，编辑当前crontab文件，可以看到提供了一些注解作说明。
在crontab中输入0 3 * * 1 ls /etc 并保存，实现在每周一早上三点执行ls /etc 命令。
再次查看crontab文件，可以看到已经保存。
2)使用crontab命令安装crontab文件，安排计划任务；
对于位于/home下的crontab文件，使用crontab <filename>载入crontab计划任务中，如图：
3)查看计划任务表，确认计划任务是否已被安排；
键入crontab -l，查看计划任务安排情况，如图：
4)删除计划任务列表。
在终端下键入crontab -r ，删除当前用户的crontab文件，如下：。
Linux操作系统的进程调度机制
Linux操作系统的进程调度机制进程调度是操作系统中重要的一项功能，它决定了在多个进程同时运行时的优先级和时间分配。
Linux操作系统采用了多种进程调度算法，包括时间片轮转调度算法、优先级调度算法和反馈调度算法，以满足不同应用场景下的需求。
一、时间片轮转调度算法时间片轮转调度算法是Linux操作系统中最常用的调度算法之一。
它将CPU时间分为一个个时间片，每个进程在一个时间片内运行，当时间片用完后，进程被暂停，CPU切换到下一个进程。
这种调度算法公平而高效，保证了各个进程都能有公平的运行时间。
二、优先级调度算法优先级调度算法是基于进程优先级的调度方法。
Linux操作系统中每个进程都有一个优先级，优先级高的进程会被优先调度执行，而优先级低的进程会被暂时延迟。
优先级调度算法可以确保重要任务的及时执行，但也可能导致低优先级进程长时间得不到执行，产生“饥饿”现象。
三、反馈调度算法反馈调度算法是一种基于进程历史行为的动态调度算法。
Linux操作系统中的反馈调度算法将进程分为多个优先级队列，新创建的进程首先进入最高优先级队列，如果某个进程的执行时间超过了一个时间限制，该进程会被降低优先级，放入下一个较低的队列中执行。
这种调度算法可以灵活地根据进程的实际运行情况进行调整，以提高系统的整体效率。
总结：Linux操作系统采用了时间片轮转调度算法、优先级调度算法和反馈调度算法等多种进程调度算法，以满足不同应用场景下的需求。
时间片轮转调度算法保证了各个进程都能有公平的运行时间；优先级调度算法可以确保重要任务的及时执行；反馈调度算法根据进程的实际运行情况进行调整，提高了系统的整体效率。
这些调度算法共同协作，保障了Linux操作系统的稳定性和性能。
操作系统实验2进程管理报告
实验一进程管理一、实验目的：1.加深对进程概念的理解，明确进程和程序的区别；2.进一步认识并发执行的实质；3.分析进程争用资源的现象，学习解决进程互斥的方法；4.了解Linux系统中进程通信的基本原理；二、实验预备内容：1.阅读Linux的sched.h源码文件，加深对进程管理概念的理解；2.阅读Linux的fork()源码文件，分析进程的创建过程；三、实验环境说明：1.此实验采用的是Win7(32bit)下虚拟机VMware-workstation-10.0.4 build-2249910；2.ubuntu 版本3.19.0；3.直接编写c文件在终端用命令行执行；4.虚拟机分配8G内存中的1024M；5.虚拟机名称knLinux；6.ubuntu用户名kn；四、实验内容：1.进程的创建：a)题目要求：编写一段程序，使用系统调用fork() 创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果，并分析原因。
b)程序设计说明：一个父进程，两个子进程，分别输出显示a,b,c。
c)源代码：d)运行结果：e)分析：由输出结果可知，运行结果不唯一，可以是abc,acb,bca等多种情况。
因为在程序中，并没有三个进程之间的同步措施，所以父进程和子进程的输出顺序是随机的。
在试验次数足够大的情况下，6中顺序都有可能出现：abc, acb, bac, bca, cab, cba。
2.进程的控制：a)修改已经编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。
i.程序设计说明：将第一个程序中输出字符的语句改为输出parent process和childprocess1&2的语句。
ii.源代码：iii.运行结果：iv.分析：发现在结果中，运行结果同第一个程序，但是在一个进程输出语句的中途不会被打断，语句都是完整的。
实验二：进程调度
实验二 进程调度一、 实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、 实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。
三、 参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2） 轮转法四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。
2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．若有可能请在图形方式下，将PCB 的调度用图形成动画显示。
五．实验过程：要求：读懂下面给出的程序，然后将其改写成由用户选择调度方式，例如：1、 FIFO2、 优先权调度3、 时间片轮转4、 退出对于每一种调度算法，由用户确定进程数，数据可以从文件读取，也可由用户手动输入。
（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO算法，优先数调度算法，时间片轮转调度算法（2）程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" \t"<<pcbs[i].status<<" \t"<<pcbs[i].time<<" \t"<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0;pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[i].time;}}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl; }//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){number++; j=i;}}if(number==1){queue[total]=j;total++;pcbs[j].finished=1;}if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){total--;}cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl;}//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){FIFO();init();privilege();init();timer();}}（3）运行结果：输入进程流文件名1.txt即可得出以下输出结果：。
《操作系统》实验二
《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解，通过实际操作，提高对操作系统设计和实现的认知。
通过实验二，我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。
二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。
b.设计一个简单的进程调度算法，如轮转法或优先级调度法。
c.实现进程间的通信机制，如共享内存或消息队列。
2、线程调度a.实现线程的创建、撤销和调度。
b.实现一个简单的线程调度算法，如协同多任务（cooperative multitasking）。
3、内存管理a.设计一个简单的分页内存管理系统。
b.实现内存的分配和回收。
c.实现一个简单的内存保护机制。
4、文件系统a.设计一个简单的文件系统，包括文件的创建、读取、写入和删除。
b.实现文件的存储和检索。
c.实现文件的备份和恢复。
三、实验步骤1、进程管理a.首先，设计一个进程类，包含进程的基本属性（如进程ID、状态、优先级等）和操作方法（如创建、撤销、阻塞、唤醒等）。
b.然后，实现一个进程调度器，根据不同的调度算法对进程进行调度。
可以使用模拟的方法，不需要真实的硬件环境。
c.最后，实现进程间的通信机制，可以通过模拟共享内存或消息队列来实现。
2、线程调度a.首先，设计一个线程类，包含线程的基本属性（如线程ID、状态等）和操作方法（如创建、撤销等）。
b.然后，实现一个线程调度器，根据不同的调度算法对线程进行调度。
同样可以使用模拟的方法。
3、内存管理a.首先，设计一个内存页框类，包含页框的基本属性（如页框号、状态等）和操作方法（如分配、回收等）。
b.然后，实现一个内存管理器，根据不同的内存保护机制对内存进行保护。
可以使用模拟的方法。
4、文件系统a.首先，设计一个文件类，包含文件的基本属性（如文件名、大小等）和操作方法（如创建、读取、写入、删除等）。
b.然后，实现一个文件系统管理器，包括文件的存储和检索功能。
linux操作系统实验2.Linux系统管理 报告
实验2.L i n u x系统管理1.实验目的Linux系统各种文件系统的特点目录和结构权限系统模型用户管理用户组管理2.实验内容Linux目录结构# ls –l用户与权限# chown xu myfile目录的存取权限# ls –ld chen(目录名)chmod命令用户的帐户信息都保存在口令文件/etc/passwd为了保证系统的安全性，LINUX系统通常会对用户的口令进行shadow处理，也就是把用户口令保存到只有root用户才可读的/etc/shadow文件中，这个文件职可以称为影子文件。
该文件包含的用户名与/etc/passwd文件中的相同，并且存储了用户加密口令等相关信息。
# adduser liang此时就会在系统中添加了一个用户名称为liang的新用户。
通过终端为新用户，设置初始密码：命令如下；# passwd liang用userdel命令删除用户#userdel aa禁用liang.以root身份登录在终端上输入命令：# passwd –l liang启用liang.以root身份登录在终端上输入命令：# passwd –u liang修改用户名，将用户名：hjq 改为hanjieqiong，命令如下锁定：“hanjieqiong“用户，使其不能登陆，命令如下：该命令是通过在shadow文件中指定帐号的口令字段前加入锁定符号“!”锁定此用户的帐号的解锁“hanjieqiong”帐号：更改用户命令外壳shell# usermod –s /bin/tcsh hanjieqiong建立新组# groupadd newclass改变用户的初始组。
# usermod –g newclass hanjieqiong将用户添加到新组。
# usermod –G newclass, lp bin(要求此用户已经存在) 删除组# groupdel newclass3.实验数据4.实验总结本次实验了解了Linux系统各种文件系统的特点，Linux系统的目录和结构Linux系统的权限系统模型，Linux系统的用户管理和用户组管理，并通过linux 命令实际操作和配置。
操作系统实验2进程调度 实验报告
（2）掌握带优先级的进程调度算法；
（3）选用面向对象的编程方法。
二、实验内容；
（1）用C语言（或其它语言，如Java）实现对N个进程采用动态优先调度算法的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
4．可动态添加、删除进程；
5.完成所有进程操作。
五、程序源代码及注释
六、实验结果分析
1、运行结果如下：
2、结果分析
首先，每次从就绪队列中选择最高优先权的进程时，需要计算出最高优先权和次高优先权之间的STARTBLOCK。即最高优先权进程运行多少个时间片后就会进入阻塞队列。每调度一次，就需要更新所有进程的信息，并判断CPUTIME是否等于ALLTIME，如果相等，则进程完成操作，需从就绪队列中删除。如果阻塞队列中进程的BLOCKTIME为0时，还需要将其转移到就绪队列中。
（5）用户可以干预进程的运行状态，程序应该设置可以让用户中断的入口，并可以通过以下命令查看，修改，终止进程。
A）create随机创建进程，进程的优先级与所需要的时间片随机决定；
B）ps查看当前进程状态
C）sleep命令将进程挂起
D）kill命令杀死进程
E）quit命令退出
（5）分析程序运行的结果，谈一下自己的认识。
三、实验原理；
无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
根据进程的五个特征：(1)动态性；(2)并发性；(3)异步性；(4)独立性；(5)结构性及三种基本状态的转换，了解各进程对资源的共享和竞争。进程并发执行时，由于资源共享，带来各进程之间的相互制约。为了反映这些制约关系和资源共享关系，在创建一个进程时，应首先创建其PCB，然后才能根据PCB中信息对进程实施有效的管理和控制。当一个进程完成其功能之后，系统则最后释放PCB，进程也随之消亡。
linux进程管理的实验报告
linux进程管理的实验报告Linux进程管理的实验报告引言：Linux操作系统是一种开源的操作系统，以其稳定性和高度可定制性而受到广泛使用。
在Linux系统中，进程管理是一个重要的组成部分，它负责控制和管理系统中运行的进程。
本实验报告旨在探讨Linux进程管理的相关概念和实践。
一、进程的基本概念进程是指在计算机系统中正在运行的一个程序实例。
每个进程都有自己的内存空间、寄存器和状态。
在Linux系统中，每个进程都有一个唯一的进程标识符（PID），用于标识和管理进程。
二、进程的创建和终止在Linux系统中，进程的创建是通过fork()系统调用来实现的。
fork()系统调用会创建一个新的进程，新进程是原进程的一个副本，包括代码、数据和堆栈等。
新进程和原进程共享相同的代码段，但是拥有独立的数据和堆栈。
进程的终止可以通过exit()系统调用来实现。
当一个进程调用exit()系统调用时，它会释放所有的资源，并通知操作系统该进程已经终止。
此外，父进程可以通过wait()系统调用来等待子进程的终止，并获取子进程的退出状态。
三、进程的调度和优先级在Linux系统中，进程的调度是由调度器负责的。
调度器根据进程的优先级和调度策略来确定下一个要运行的进程。
Linux系统中有多种调度策略，如先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（Round Robin）等。
进程的优先级用一个数字表示，范围从-20到19，其中-20表示最高优先级，19表示最低优先级。
较高优先级的进程会被优先调度，以保证其能够及时响应用户的请求。
四、进程的状态转换在Linux系统中，进程可以处于不同的状态，如运行态、就绪态和阻塞态等。
进程的状态转换是由操作系统根据进程的行为和外部事件来控制的。
当一个进程被创建时，它处于就绪态，等待被调度执行。
当进程获得CPU资源并开始执行时，它进入运行态。
当进程需要等待某个事件发生时，如等待用户输入或等待某个文件读写完成，它会进入阻塞态。
实验二 进程管理(linux)
实验二进程管理（Linux）一、实验类型本实验为设计性实验。
二、实验目的与任务1）加深对进程概念的理解，明确进程和程序的区别。
2）进一步认识并发执行的实质三、预习要求1）进程的概念2）进程控制的概念及内容3）进程的并发执行4）熟悉互斥的概念5）用到的Linux函数有：fork()，lockf()等。
四、实验基本原理使用fork()系统调用来创建一个子进程，父进程和子进程并发执行，交替输出结果。
使用lockf()系统调用对临界区进行加锁操作，实现对共享资源的互斥使用。
五、实验仪器与设备（或工具软件）实验设备：计算机一台，软件环境要求： Linux操作系统和gcc编译器。
六、实验内容1）进程的创建编写一段程序，使用系统调用fork( ) 创建两个子程序。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。
运行程序10次，观察记录屏幕上的显示结果，并分析原因。
2）进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。
如果在程序中使用系统调用lockf()来给每一个进程加锁，可以实现进程间的互斥，观察并分析出现的现象。
(1)进程的创建参考程序如下：#include<stdio.h>main(){int p1,p2;while((p1=fork())==-1); //p父进程p1子进程1if(p1!=0){while(((p2=fork())==-1); //p父进程p2子进程2if(p2==0) putchar('b');else putchar('c');}else putchar('a');}运行结果：略cab bca bac分析：原因：Fork（）函数有三个返回值：1.-1 执行不成功2.0 表示当前正在执行子进程3.其他数值表示当前正在执行父进程，值是子进程的进程标识符PID4.获取当前进程的标识符getpid()5.获取当前进程的父进程的标识符getppid()(2)进程的控制参考程序如下#include<stdio.h>main(){int p1,p2,i;while ((p1=fork())==-1); // 父进程p，子进程p1if(p1==0){for(i=0;i<500;i++)printf("child_p1_ %d\n",i);}else{while((p2=fork())==-1);//父进程p,子进程p2if(p2==0)for(i=0;i<500;i++)printf("chind_p2_ %d\n",i);else for(i=0;i<500;i++)printf("father_p_%d\n",i);}}运行结果：略分析：由于函数printf()输出和字符串之间不会被中断，因此字符串内部的字符顺序输出不变。
实验2 Linux进程控制
实验2 Linux 进程控制一. 实验目的1．学会查看和杀死进程。
2．加深对进程概念的理解，明确进程与程序的区别。
3．熟悉linux 下vi 的使用。
二. 实验指导1. 查看系统中的进程格式：ps [选项]例如：ps //显示当前用户在shell 下所运行的进程。
ps -u osmond //显示用户osmond 的进程。
ps -aux //显示系统中正在运行的所有进程的详细信息。
2. 杀死系统中的进程格式：kill [signal] PIDPID 是进程的识别号；signal 是向进程发出的进程信号。
3. vi 文本编辑工具进入Linux 的字符界面，输入vi file ，进入vi 编辑程序。
vi 提供了输入模式（insert mode ）和命令模式（command mode ）。
使用者进入vi 后，即处在命令模式下，此刻键入i 转换到输入模式。
在输入模式下，按ESC 可切换到命令模式。
命令模式下，常用的指令有：：q! 离开vi ，并放弃刚在缓冲区内编辑的内容：wq 将缓冲区内的资料写入磁盘中，并离开vi：n 光标直接跳到第n：w 将当前编辑的内容存盘ESC 离开输入模式4. 有关进程控制系统调用三．实验内容1. 请在字符界面下完成下列作业控制操作：• 显示当前运行的进程• 运行cat 命令函数名调用格式 功能 fork() int fork()例：pid=fork(); 创建一个新进程，fork( )返回值意义如下： 0：在子进程中，pid 变量保存的fork( )返回值为0，表示当前进程是子进程。
>0：在父进程中，pid 变量保存的fork( )返回值为子进程的id 值（进程唯一标识符）。
-1：创建失败。
execl() int execl(新程序名，0) 重新加载进程，用新程序替换原进程。
如execl("bin/ls",0); 用bin/ls 替换原进程。
wait （） int wait(int status) 例： wait(); 等待子进程运行结束。
操作系统实验二进程调度
操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。
2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。
可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。
实验二Linux进程调度及用户管理
实验二1 实验名称:Ｌｉnux进程调度及用户管理2 实验目标２.1 掌握手工启动前后台作业的方法。
２。
2 掌握进程与作业管理的相关Ｓhｅll命令.２。
３掌握at调度和cｒon调度的设置方法。
2。
4了解系统性能监视的基本方法。
2．5 掌握用户管理基本方法和命令.2．6 具有批量新建用户能力。
２。
７掌握非实时的通信方式。
３实验环境和准备3.1Wiｎdｏws ＸＰ下基于“ＶMｗａre Workｓtatｉon”虚拟机环境的Red HaｔEntｅrpriｓe Linux Serveｒ 5系统。
３.2将主机改为具有个人学号后３位特征的名称。
４实验要求、步骤及结果4．1复习vi的基本操作；实现用户间非实时通信;进行作业和进程的基本管理。
【操作要求1】root用户在个人用户主目录下，利用vi新建sｔudｅnｔ。
txt文件;存盘退出。
内容参见下表左列。
sｔudent。
txt文件内容password．txt文件内容S０１:x：800:800：:／hoｍe／S01:／bin/baｓｈＳ02：x:８０１：8０0:：/ｈomｅ／S0２：/bｉn/bash S0３：x：802：８0０：：/hoｍe/S03：/bｉn／bash Ｓ０4：ｘ:8０3:800：：/ｈｏme/Ｓ04:/bin／ｂａshS０5：x:80４:800：：/ｈomｅ/S０5:/bin/bａｓh S06:x:805:8０0:：／hｏme/S0６：/bｉn/bashS07:x：806：8０0::/ｈoｍe／S07:／biｎ／bａsh Ｓ0８:ｘ：807：800：:/hｏｍe/Ｓ０8:/bin／bash Ｓ0９：x：8０8：80０:：/home/S0９：／bin/bａｓｈS１０：x:８09:８０0:：/hoｍｅ/Ｓ10:/bｉｎ/bas ｈS11:x：81０:８００：：／ｈｏme／S1１：/bin/bash Ｓ01:123456７8 S02：123４5678 Ｓ03：12345６78 S04：1234567８S０5:12345６78【操作步骤１-新建】【操作步骤２－存盘】【操作要求2】利用vｉ新建pasｓｗord．txt文件；内容参见上表右列。
进程管理操作系统linux实验
实验进程管理（一）进程的创建实验实验目的1、掌握进程的概念，明确进程的含义2、认识并了解并发执行的实质实验内容1、编写一段程序，使用系统调用fork()创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。
试观察记录屏幕上的显示结果，并分析原因。
2、修改上述程序，每一个进程循环显示一句话。
子进程显示'daughter…'及'son ……'，父进程显示'parent ……'，观察结果，分析原因。
实验准备（1）阅读LINUX的fork.c源码文件（见附录二），分析进程的创建过程。
（2）阅读LINUX的sched.c源码文件(见附录三)，加深对进程管理概念的认识。
实验指导一、进程UNIX 中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。
一个进程实体由若干个区（段）组成，包括程序区、数据区、栈区、共享存储区等。
每个区又分为若干页，每个进程配置有唯一的进程控制块PCB，用于控制和管理进程。
PCB 的数据结构如下：1、进程表项（Process Table Entry）。
包括一些最常用的核心数据：进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB 的指针P_Link、指向U 区进程正文、数据及栈在内存区域的指针。
2、U 区（U Area）。
用于存放进程表项的一些扩充信息。
每一个进程都有一个私用的U区，其中含有：进程表项指针、真正用户标识符u-ruid(read user ID)、有效用户标识符u-euid(effective user ID)、用户文件描述符表、计时器、内部I/O参数、限制字段、差错字段、返回值、信号处理数组。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二
1 实验名称：Linux进程调度及用户管理
2 实验目标
2.1 掌握手工启动前后台作业的方法。
2.2 掌握进程与作业管理的相关Shell命令。
2.3 掌握at调度和cron调度的设置方法。
2.4了解系统性能监视的基本方法。
2.5 掌握用户管理基本方法和命令。
2.6 具有批量新建用户能力。
2.7掌握非实时的通信方式。
3 实验环境和准备
3.1Windows XP下基于“VMware Workstation”虚拟机环境的Red Hat Enterprise Linux Server 5系统。
3.2将主机改为具有个人学号后3位特征的名称。
4 实验要求、步骤及结果
4.1复习vi的基本操作；实现用户间非实时通信；进行作业和进程的基本管理。
【操作要求1】root用户在个人用户主目录下，利用vi新建student.txt文件；存盘退出。
内容参见下表左列。
【操作步骤1-新建】
【操作步骤2-存盘】
【操作要求2】利用vi新建password.txt文件；内容参见上表右列。
【操作步骤】
【操作要求3】将vi password.txt作业挂起；显示当前所有进程的详细信息。
【操作步骤1-挂起】
【操作步骤2-显示】
【操作要求4】将挂起的vi作业切换到前台；继续向password.txt文件输入以下内容，输入完成后存盘退出。
password.txt文件的后段内容：
S06:12345678
S07:12345678
S08:12345678
S09:12345678
S10:12345678
S11:12345678
【操作步骤1-作业切换】
【操作步骤2-vi操作】
【操作要求5】返回虚拟终端1（root用户）；将helen用户的进程优先数改为-3。
【操作步骤】
【操作要求6】返回虚拟终端2（helen用户）；后台再次启动ftp进程；显示进程的详细信息。
【操作步骤1-启动进程】
【操作步骤2-显示进程】
4.2基本用户管理和组群管理
【操作要求1】创建student用户；启动虚拟终端3，用student用户登录；修改自己的登录口令。
【操作步骤-创建】
【操作步骤-修改口令】
【操作要求2】将普通用户student切换为超级用户并使用相应环境，比较超级用户和普通用户工作环境。
【操作步骤】
【工作环境比较】
【操作要求3】新建名为“class15”的组群，GID=800。
【操作步骤及结果】
注：可直接跳到4.3批量新建多个用户帐号
【操作要求4】利用vi命令，修改/etc/hosts文件的最后一列的内容与现主机名相同。
学习并利用“mail”命令向student用户发送一封邮件，内容为“Please hand in the experimental report.”，主题“Urge the experimental report.”，并抄送给helen用户。
【操作步骤1-vi】
【操作步骤2-学习】
【操作步骤3-发邮件】
【操作要求5】启动虚拟终端2；helen用户登录，接收、阅读邮件，并回复“I know”；后台启动ftp进程；显示进程的优先级。
【操作步骤1-收邮件并回复】
【操作步骤2-启动进程】
【操作步骤3-显示优先级】
【操作要求6】删除student用户同时删除其个人用户主目录。
【操作步骤-删除用户】
4.3批量新建多个用户帐号
【操作要求1】为某学习小组的10位同学批量创建用户账号。
用户账号为“S”+ 2位顺序号，即
S01～S11，初始口令均为“12345678”，且均隶属于GID为800的组群、假设UID从800开始顺序编号。
注：用户信息保存在student.txt文件中，口令保存在password.txt中。
（参见本文件4.1）【截取/etc/group相关内容】
【操作步骤1】
【截取/etc/passwd相关内容】
提示：cat命令，截取UID>=500内容
【截取/etc/shadow相关内容】
【操作步骤2】
【截取/etc/passwd相关内容】
【截取/etc/shadow相关内容】
【操作步骤3】
【截取/etc/passwd相关内容】
【截取/etc/shadow相关内容】
【操作步骤4】
【截取/etc/passwd相关内容】
【截取/etc/shadow相关内容】
【抄写student.txt文件第一行和最后一行内容】
St001:x:800:800::/home/st001:/bin/bash
……
St010:x:800:800::/home/st010:/bin/bash
【抄写password.txt文件第一行和最后一行内容】
St001:12345678
……
St010:12345678
【操作要求2】启动虚拟终端3，S10登陆。
【截取登陆界面】
4.4 at进程调度
【操作要求1】设置一个10分钟后执行的at调度。
要求：统计系统中登录用户数，并将结果保存到who.txt 文件中；向所有登录用户发送“The Computer Will Shutdown in 5 Minutes!”的消息；并在5分钟后重新启动系统。
【操作步骤-设置at调度】
【操作步骤-at命令】
【操作要求2】显示进程详细状态；显示等待中的at调度。
【操作步骤1-显示进程】
【操作步骤2-显示at调度】
【操作要求3】删除等待中的at调度。
【操作步骤】
4.5 cron进程调度
【操作要求1】查看系统时间。
设置crontab调度，（时间节点依照上课时间而变，主要还是要看到执行结果）①每天晚上8:50查看系统中进程的状态；②每周一~五的9:00统计登入用户数并保存在who.txt文件中。
③每月13,18,20日16:55向各位登录用户发送“Pleas submit financial statement.”信息。
【操作步骤1-查看系统时间】
【操作步骤2-设置cron调度】
【操作要求2】显示crontab调度的内容。
【操作步骤及结果】
【操作要求3】查看crontab调度的执行结果。
【操作步骤及结果截图①】
【操作步骤及结果截图②】
【操作步骤及结果截图③】
5 评价
5.1实验评价
实验涉及到了上课的所有内容，设计十分全面和周到。
不仅让我们回忆了自己学习过的知识，巩固了相关知识，同时又有关于进程的阅读要求，扩展了视野。
5.2自我评价
整个实验重点在于了解Linux操作系统的桌面环境和掌握基本shell命令的使用。
知识点在课堂上上机操作的时候老师教过，但还有一部分的题需要我们自己学习老师发的辅导资料完成实验，这其中就考验了我们的自觉性。
我们遇到不懂的问题可以问同学或者上网查但绝对不可以直接不动脑子的放弃或抄。
比如：最后一个题目中编辑用户信息文件和用户口令文件的格式不太懂，我经过网上搜查资料，彻底搞懂之后完成题目。
6 思考题
6.1简述线程与进程的主要区别。
线程是指进程内的一个执行单元,也是进程内的可调度实体。
进程是具有一定独立功能的程序关于某
个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。
线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计数器为其执行上下文。
多线程主要是为了节约CPU时间，发挥利用，根据具体情况而定。
线程的运行中需要使用计算机的内存资源和CPU。
6.2 Linux操作系统可以描述进程的哪几种状态。
运行状态（正在使用CPU）、就绪状态（等待分配CPU）、堵塞状态（等待输入/输出等）
6.3简述从“程序”到“作业”再到“进程”的动态演变过程。
“程序”正准备进入到内存，被称之为“作业”。
然而当这个作业进入到内存后，称之为“进程”。
程序被加载到内存，首地址送入程序计数器。
作业从外存的后备队列进入内存的就绪队列等待运行，依照某种算法将外存上处于后备队列中的若干个作业调入内存，PCB记录进程当前时刻的状态及与其它进程、资源的关系，系统中所有PCB构成控制并发程序执行，维护系统环境的依据。