实验三 进程管理
操作系统实验报告进程管理
操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。
进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。
本实验报告将介绍进程管理的基本概念、原理和实验结果。
一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。
线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。
进程和线程是操作系统中最基本的执行单位。
2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。
就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。
3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。
常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。
二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。
通过PCB，操作系统可以对进程进行管理和控制。
2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。
进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。
进程的创建和撤销是操作系统中的基本操作之一。
3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。
常见的进程同步与通信机制包括互斥锁、信号量和管道等。
三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。
通过该程序，我们可以观察到不同调度算法对系统性能的影响。
实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。
操作系统实验,实验3, 进程管理 (1)
在图形界面上利用终端通过命令“su - ”切换到超级用户，编辑文件 “job”； 按组合键[Ctrl+Alt+F2]切换到第二个虚拟终端（超级用户）； 输入命令“at –f job now+1 minute”，设置1分钟后执行at调度内容； 稍等后观察at调度的执行效果，再切换到第一个虚拟终端观察at调度 的执行效果；
切换到第一个虚拟终端观察at调度的执行效果（5分钟后系统将执行重 启调度任务）。
[操作要求2] 设置一个调度，要求1分钟后执行文件job中的作业。 文件job的内容为： find /home/jkx/ -name “*.c” > /home/jkx/fdresult wall user jkx, all code files have been searched out! Please check out. [操作步骤]
续表
守 护 进 程 innd Usenet新闻服务器 功 能 说 明
linuxconf
lpd named netfs network
允许使用本地WEB服务器作为用户接口来配置机器
打印服务器 DNS服务器 安装NFS、Samba和NetWare网络文件系统 激活已配置网络接口的脚本程序
nfsd
portmap postgresql routed sendmail
事件（例如xinetd和lpd）
启动守护进程有如下几种方法
在引导系统时启动 人工手动从shell提示符启动
系统启动script的执行期间 被启动（/etc/rc.d） 任何具有相应执行 权限的用户
使用crond守护进程启动
执行at命令启动
守护进程一般由系统在开机时通过脚本或root
实验三-进程管理
实验三进程管理一、实验目的1．熟悉和理解进程和进程树的概念，掌握有关进程的管理机制2．通过进程的创建、撤销和运行加深对进程并发执行的理解3．明确进程与程序、并行与串行执行的区别4．掌握用C 程序实现进程控制的方法二、实验学时2学时三、实验背景知识所涉及的系统调用1、exec( )系列（exec替换进程映像）系统调用exec( )系列，也可用于新程序的运行。
fork( )只是将父进程的用户级上下文拷贝到新进程中，而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。
exec( )系列中的系统调用都完成相同的功能，它们把一个新程序装入内存，来改变调用进程的执行代码，从而形成新进程。
如果exec( )调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id 与调用进程相同。
exec( )没有建立一个与调用进程并发的子进程，而是用新进程取代了原来进程。
所以exec( )调用成功后，没有任何数据返回，这与fork( )不同。
exec( )系列系统调用在UNIX系统库unistd.h中，共有execl、execlp、execle、execv、execvp五个，其基本功能相同，只是以不同的方式来给出参数。
#include<unistd.h>int execl(const cha r *pathname, const char *arg, …);int execlp(const char *, const char *arg, …);int execle(const char *pathname, const char *arg, …, const char *envp[ ]);int execv(const char *pathname, char *const argv[ ]);int execvp(const char *, char *const argv[ ]);参数：path参数表示你要启动程序的名称包括路径名。
操作系统实验3-进程控制
WORD wMajorReq=(WORD)(dwVerReq>16);
WORD wMinorReq=(WORD)(dwVerReq&0xffff);
::cout<<"Process ID:"<<dwIdThis<<",requires OS:"<<wMajorReq<<wMinorReq<<::endl;
{
//改变优先级
::SetPriorityClass(
::GetCurrentProcess(), //利用这一进程
HIGH_PRIORITY_CLASS); //改变为high
//报告给用户
::cout<<"Task Manager should indicate this "
"process is high priority."<<::endl;
//设置版本信息的数据结构，以便保存操作系统的版本信息
OSVERSIONINFOEX osvix;
::ZeroMemory(&osvix,sizeof(osvix));
osvix.dwOSVersionInfoSize=sizeof(osvix);
//提取版本信息和报告
::GetVersionEx(reinterpret_cast<LPOSVERSIONINFO>(&osvix));
Parent();
}
return 0;
}
分析：程序4-3.cpp说明了一个进程从“生”到“死”的整个一生，第一次执行时，它创建一个子进程，其行为如同“父亲”。在创建子进程之前，先创建一个互斥的内核对象，其行为对于子进程来说，如同一个“自杀弹”。当创建子进程时，就打开了互斥体并在其他线程中进行别的处理工作，同时等待着父进程使用ReleaseMutex（）API发出“死亡”信号。然后用Sleep（）API调用来模拟父进程处理其他工作，等完成时，指令子进程终止。
操作系统原理实验3-进程管理
《操作系统原理》实验报告
实验序号：3 实验项目名称：进程管理
一、实验目的及要求
1. 加深对进程概念的理解，明确进程和程序的区别。
2. 进一步认识并发执行的实质。
3. 掌握Linux操作系统下的进程的创建与撤销。
二、实验设备（环境）及要求
1.虚拟机VMware Workstation、Ubuntu操作系统和C语言编程。
2.创建多个父进程与子进程，并撤销这些进程。
3.编写一段程序，使用系统调用fork()创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符a；子进程分别显示字符b和字符c。
试观察记录屏幕上的显示结果并分析原因。
三、实验内容与步骤
1.创建多个父进程与子进程
2.撤销这些进程
kill命令
3.编写程序
4.运行
四、实验结果与数据处理
分析：从进程并发执行来看，输出bca或abc的任意排列
原因：fork()创建进程所需要的时间要多于输出一个字符的时间，因此在主进程创建进程2的同时，进程1就输出了”b”，而进程2和主程序的输出次序是有随机性的，所以会出现多种可能结果。
五、分析与讨论
fork函数的原理是:一个现有进程可以调用fork函数创建一个新进程。
由fork 创建的新进程被称为子进程(child process)。
fork 函数被调用一次但返回两次。
两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。
六、教师评语
成绩
签名：
日期：。
电大操作系统实验报告3_ 进程管理实验
电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一，本次实验的目的是通过实际操作和观察，深入理解进程的概念、状态转换、进程调度以及进程间的通信机制，掌握操作系统中进程管理的基本原理和方法，提高对操作系统的整体认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C 语言，开发工具为 Visual Studio 2019。
三、实验内容及步骤（一）进程的创建与终止1、编写一个 C 程序，使用系统调用创建一个子进程。
2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。
3、子进程执行一段简单的计算任务，父进程等待子进程结束后输出结束信息。
以下是实现上述功能的 C 程序代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>include ＜unistdh>int main(）｛pid_t pid;pid ＝ fork(）；if （pid ＜ 0) ｛printf(＂创建子进程失败\n"）；return 1;｝ else if （pid ＝＝ 0) ｛printf(＂子进程：我的进程 ID 是％d，父进程 ID 是％d\n"，getpid(）， getppid(））；int result ＝ 2 ＋ 3;printf(＂子进程计算结果：2 ＋ 3 ＝％d\n"， result)；exit(0)；｝ else ｛printf(＂父进程：我的进程 ID 是％d，子进程 ID 是％d\n"，getpid(）， pid)；wait(NULL)；printf(＂子进程已结束\n"）；｝return 0;｝｀｀｀编译并运行上述程序，可以观察到父进程和子进程的输出信息，验证了进程的创建和终止过程。
（二）进程的状态转换1、编写一个 C 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。
操作系统实验3进程的创建控制实验
操作系统实验3进程的创建控制实验实验三的目标是通过实现一个进程控制程序，来加深我们对进程创建和控制机制的理解，并通过实践来熟悉和掌握相关的编程技巧。
在进行实验之前，我们需要先了解进程的一些基本概念和相关知识。
首先，进程的创建是通过操作系统中的系统调用来完成的。
在Linux系统中，常用的创建进程的系统调用有fork(和exec(。
fork(系统调用可以创建一个新的进程，该进程与调用fork(的进程几乎完全相同；而exec(系统调用则在新创建的进程中执行一个新的程序。
另外，进程的控制机制主要是通过进程的状态来实现的。
进程可以处于就绪状态、运行状态和阻塞状态。
就绪状态的进程可以被调度器选择后立即运行，而阻塞状态的进程则需要等待一些条件满足后才能被唤醒并变为就绪状态。
实验三的具体内容包括：1. 编写一个程序，通过调用fork(创建多个子进程。
子进程和父进程可以并行执行，共享程序的代码和数据段。
2. 子进程通过调用exec(系统调用执行不同的程序。
可以通过调用不同的exec(函数或者传入不同的参数来执行不同的程序。
3. 子进程执行的程序可能会产生不同的结果，比如输出不同的字符串或者产生不同的返回值。
我们可以通过wait(系统调用等待子进程退出，并获取子进程的返回值。
4. 父进程可以通过调用waitpid(系统调用来选择等待一些特定的子进程，以及获取特定子进程的返回值。
通过实验三的实践，我将更加深入地了解进程的创建和控制机制。
实验三的实验结果将让我熟悉和掌握相关的编程技巧，为我今后更加熟练地编写和控制进程打下坚实的基础。
总之，实验三是一个非常有意义的实验，将帮助我更加深入地理解进程的创建和控制机制，并通过实践获得相关的编程技巧。
这将对我今后的学习和实践有很大的帮助。
进程管理实验报告源代码(3篇)
第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。
2. 掌握进程的创建、调度、同步和通信等操作。
3. 通过编程实现简单的进程管理功能。
二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);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;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。
进程管理实验报告_共10篇 .doc
★进程管理实验报告_共10篇范文一：_进程管理实验报告进程管理实验报告一、进程与线程1.实验目的：1.通过本实验学习Linux中创建进程的方法。
2.学习系统调用fork的使用方法。
3.学习系统调用exec族调用的使用方法。
2.实验准备1．进程的创建创建一个进程的系统调用很简单，只要调用fork函数就可以了。
#includepid_tfork()；当一个进程调用了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族调用有以下五个函数：intexecl(constchar*path,constchar*arg,?);intexeclp(constchar*file,constchar*arg,?);intexecle(constchar*path,constchar*arg,?);intexecv(constchar*path,constchar*argv[]);intexecvp(constchar*file,constchar*argv[]);exec族调用可以执行给定程序。
进程管理实验报告分析(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. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
Linux实验：进程管理
实验3：进程管理实验目的：1.掌握进程管理的相关命令；2.理解Linux进程管理的实质。
实验材料：一、实验内容及步骤Linux系统上所有运行的东西都可以称之为一个进程。
每个用户任务、每个系统管理守护进程，都可以称之为进程。
1.ps功能:用于查看进程状态。
使用该命令可以确定有哪些进程正在运行和运行的状态、进程是否结束、进程有没有僵死、哪些进程占用了过多的资源等等。
命令的格式：ps [options]主要参数：最常用的三个参数是u、a、x实例：ps –u 查看系统进程，显示面向用户的格式ps –a 查看系统中与tty相关的进程图12.top功能:显示系统当前的进程和其他状况；可以通过用户按键来不断刷新当前状态。
top 命令提供了实时的对系统处理器的状态监视；该命令可以按CPU使用。
内存使用和执行时间对任务进行排序；而且该命令的很多特性都可以通过交互式命令或者在个人定制文件中进行设定。
命令的格式：top [-] [d delay] [q] [c] [s] [S] [i]主要参数：d 指定每两次屏幕信息刷新之间的时间间隔。
当然用户可以使用s交互命令来改变之。
s 在安全模式中运行。
这将去除交互命令所带来的潜在危险。
c 显示整个命令行而不只是显示命令名。
实例：top 查看系统状况图2 top -n 10 显示更新十次后退出图3 top -n 2 -b > top.log 将更新显示二次的结果输出到名称为top.log 的档案里图43.，kill及其带参数的使用kill 进程ID图54，crontab命令试写一个定时任务，每周五11：30提示"明天休息，注意备份数据库" (运行命令为：wall "明天休息，注意备份数据库")vi aaa30 11 * * 5 wall “明天休息，注意备份数据库”crontab aaa图6。
实验三Linux系统的进程管理
实验三Linux系统的进程管理一、实验目的1.掌握进程管理的相关命令；2.理解Linux进程管理的实质。
二、项目背景在 Windows 2000/2003系统下，安装VMWare Workstation，并安装了RedHat Linux.三、实验内容1、前期准备打开系统，选择“主菜单”→“系统工具”→“终端”命令进入命令行环境，2、1）ps功能:用于查看进程状态。
使用该命令可以确定有哪些进程正在运行和运行的状态、进程是否结束、进程有没有僵死、哪些进程占用了过多的资源等等。
注意：最常用的三个参数是u、a、x2）top功能:显示系统当前的进程和其他状况；可以通过用户按键来刷新当前状态。
实例：查看系统状况 $ top 显示更新十次后退出 $ top-n103）nice 功能：用于设置优先权。
命令的格式：nice [OPTION] [COMMAND [ARG]...]实例：将ls命令的优先权等级加1并且执行ls命令： $nice-n1ls4）free功能：用来显示内存状态。
（2）实训内容与步骤（25分钟）：1) 使用ps命令显示用户启动的进程，使用kill命令删除一个已经不再使用的进程。
# ps –Au root (A参数显示root用户启动的进程，u参数显示进程详细信息)# ps -r (r参数只显示正在运行的进程)# kill No1 (终止进程号为No1的进程)2) 中止某一正在执行的进程，然后重新启动放到后台继续执行。
$ yes>/dev/null (启动一个进程)按Ctrl+z键中止一个进程。
系统显示：［1］+ stopped yes >/dev/null$ bg (将此进程放到后台执行)系统显示：［1］+ yes > /dev/ null &（3）练习学过的linux下的常用软件如office文档等（35分钟）：练习过程中出现问题可以询问教师，更提倡利用网络查询，实现自我提高，学会自我学习。
进程的管理实验报告结论
一、实验背景及目的进程是操作系统中基本的活动单位，进程管理是操作系统核心功能之一。
为了深入理解进程的概念、进程状态转换、进程同步与互斥等知识，我们进行了进程管理实验。
本次实验旨在通过编写程序，模拟进程的创建、调度、同步与互斥等操作，加深对进程管理的理解。
二、实验内容及方法1. 进程创建与状态转换（1）使用系统调用fork()创建子进程，观察父进程和子进程的状态转换过程。
（2）使用系统调用exec()替换子进程的内容，观察子进程状态变化。
2. 进程调度（1）编写进程调度程序，实现最高优先数优先调度算法和先来先服务调度算法。
（2）模拟进程就绪队列，观察调度算法对进程执行顺序的影响。
3. 进程同步与互斥（1）使用信号量实现进程同步，观察进程同步效果。
（2）使用互斥锁实现进程互斥，观察进程互斥效果。
4. 进程通信（1）使用管道实现进程间通信，观察通信效果。
（2）使用共享内存实现进程间通信，观察通信效果。
三、实验结果与分析1. 进程创建与状态转换实验结果显示，使用fork()创建子进程后，父进程和子进程的状态均为运行态。
当父进程调用exec()替换子进程内容后，子进程状态变为僵尸态，父进程状态变为运行态。
这说明进程在创建和替换过程中，其状态发生了相应的变化。
2. 进程调度实验结果显示，最高优先数优先调度算法和先来先服务调度算法均能正确执行。
最高优先数优先调度算法下，优先级高的进程先执行；先来先服务调度算法下，先到达的进程先执行。
这说明两种调度算法均能实现进程的合理调度。
3. 进程同步与互斥实验结果显示，使用信号量实现进程同步时，进程能正确地按照规定的顺序执行；使用互斥锁实现进程互斥时，进程能正确地实现互斥访问共享资源。
这说明信号量和互斥锁在进程同步与互斥方面具有重要作用。
4. 进程通信实验结果显示，使用管道实现进程间通信时，进程能正确地接收和发送数据；使用共享内存实现进程间通信时，进程能正确地访问共享内存中的数据。
操作系统实验三实验报告
（一）进程创建
编写程序实现创建多个进程，并观察进程的执行情况。通过调用Windows API函数｀CreateProcess`来创建新的进程。在创建进程时，设置不同的参数，如进程的优先级、命令行参数等，观察这些参数对进程执行的影响。
（二）进程控制
实现对进程的暂停、恢复和终止操作。使用｀SuspendThread`和｀ResumeThread`函数来暂停和恢复进程中的线程，使用｀TerminateProcess`函数来终止进程。通过控制进程的执行状态，观察系统的资源使用情况和进程的响应。
（一）进程创建实验结果与分析
创建多个进程后，通过任务管理器观察到新创建的进程在系统中运行。不同的进程优先级设置对进程的CPU占用和响应时间产生了明显的影响。高优先级的进程能够更快地获得CPU资源，执行速度相对较快；而低优先级的进程则在CPU资源竞争中处于劣势，可能会出现短暂的卡顿或计一个多进程同步的程序，使用信号量、互斥量等同步机制来协调多个进程的执行。例如，实现一个生产者消费者问题，多个生产者进程和消费者进程通过共享缓冲区进行数据交换，使用同步机制来保证数据的一致性和正确性。
四、实验步骤
（一）进程创建实验步骤
1、打开Visual Studio 2019，创建一个新的C+＋控制台应用程序项目。
六、实验中遇到的问题及解决方法
（一）进程创建失败
在创建进程时，可能会由于参数设置不正确或系统资源不足等原因导致创建失败。通过仔细检查参数的设置，确保命令行参数、环境变量等的正确性，并释放不必要的系统资源，解决了创建失败的问题。
（二）线程控制异常
在暂停和恢复线程时，可能会出现线程状态不一致或死锁等异常情况。通过合理的线程同步和错误处理机制，避免了这些异常的发生。在代码中添加了对线程状态的判断和异常处理的代码，保证了线程控制的稳定性和可靠性。
实验三 windows任务管理器的进程管理
五、实验总结：
通过这次实验，让我对Windows XP的任务管理器有了很好的了解，也知道了如何通过选项卡控制各个进程的优先级。刚开始实验时只知道如何打开Windows XP的任务管理器，但对于Windows XP的任务管理器中各个选项卡的运用不是很熟悉。
要查看正在运行程序的优先级，可单击“进程选项卡”，单击“查看”菜单，单击“选择列”>“基于优先级”命令，然后单击“确定”。
为更改正在运行程序的优先级，可在“进程”选项卡上右键单击你要更改的程序，指向“设置优先级”然后单击所需的选项。
更改进程的优先级，可以使其运行的更快或更慢，但也可能对其他进程的性能有相反的影响。
system
00
7,392k
Smss.exe
system
00
448k
Svchost.exe
system
00
5,008k
SOSOUpdate.exe
system
00
5,184k
mDNSResponder..
system
00
3,816k
360rps.exe
system
00
7,000k
ati2evxx.exe
这次试验主要是在老师和同学的帮助下完成的，让我对Windows XP的任务管理器有了一个初步的了解，感到这门课十分神奇。
六、指导教师评语及成绩：
教室签名
成绩
批阅日期
00
33,468k
Ctfmon.exe
Administrator
00
5,244k
360tray.exe
实验三 进程管理
实验三进程管理背景知识Windows所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。
每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。
通常应用程序的框架负责调用ExitProcess() 函数。
对于C++ 运行库来说，这一调用发生在应用程序的main() 函数返回之后。
1. 创建进程CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。
表3-4详细地列出了每个参数的类型和名称。
表3-4 CreateProcess() 函数的参数可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。
然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。
经常使用的标志是CREA TE_SUSPNDED，告诉主线程立刻暂停。
当准备好时，应该使用ResumeThread() API来启动进程。
另一个常用的标志是CREA TE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口。
这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。
接着是CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。
第一个参数是lpEnvironment参数，指明为新进程提供的环境；第二个参数是lpCurrentDirectory，可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构所必需的，用于在必要时指明新应用程序的主窗口的外观。
进程管理实验报告
进程管理实验报告进程管理实验报告引言：进程管理是操作系统中的重要概念，它负责调度和控制计算机系统中的各个进程，确保它们能够有序地执行。
本实验旨在通过实际操作和观察，深入了解进程管理的原理和方法，并通过实验结果分析其影响因素和优化策略。
实验一：进程创建与终止在本实验中，我们首先进行了进程的创建和终止实验。
通过编写简单的程序，我们能够观察到进程的创建和终止过程，并了解到进程控制块（PCB）在其中的作用。
实验结果显示，当一个进程被创建时，操作系统会为其分配一个唯一的进程ID，并为其分配必要的资源，如内存空间、文件描述符等。
同时，操作系统还会为该进程创建一个PCB，用于存储该进程的相关信息，如进程状态、程序计数器等。
当我们手动终止一个进程时，操作系统会释放该进程所占用的资源，并将其PCB从系统中删除。
这样，其他进程便可以继续使用这些资源，提高系统的效率和资源利用率。
实验二：进程调度算法进程调度算法是决定进程执行顺序的重要因素。
在本实验中，我们通过模拟不同的进程调度算法，比较它们在不同场景下的表现和效果。
我们选择了三种常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）和轮转调度（RR）。
通过设置不同的进程执行时间和优先级，我们观察到不同调度算法对系统吞吐量和响应时间的影响。
实验结果显示，FCFS算法适用于执行时间较短的进程，能够保证公平性，但在执行时间较长的进程出现时，会导致等待时间过长，影响系统的响应速度。
SJF 算法在执行时间较长的进程时表现出色，但对于执行时间较短的进程，可能会导致饥饿现象。
RR算法能够在一定程度上平衡各个进程的执行时间，但对于执行时间过长的进程，仍然会影响系统的响应速度。
实验三：进程同步与互斥在多进程环境中，进程之间的同步和互斥是必不可少的。
在本实验中，我们通过模拟进程间的竞争和互斥关系，观察进程同步与互斥的实现方式和效果。
我们选择了信号量机制和互斥锁机制作为实现进程同步和互斥的方法。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统实验报告三
操作系统实验报告三一、实验目的本次操作系统实验的目的在于深入了解操作系统的进程管理、内存管理和文件系统等核心功能，通过实际操作和观察，增强对操作系统原理的理解和掌握，提高解决实际问题的能力。
二、实验环境本次实验在 Windows 10 操作系统环境下进行，使用了 Visual Studio 2019 作为编程工具，并借助了相关的操作系统模拟软件和调试工具。
三、实验内容与步骤（一）进程管理实验1、创建多个进程使用 C+＋语言编写程序，通过调用系统函数创建多个进程。
观察每个进程的运行状态和资源占用情况。
2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。
分析在不同并发情况下程序的执行结果，理解进程同步的重要性。
（二）内存管理实验1、内存分配与回收实现一个简单的内存分配算法，如首次适应算法、最佳适应算法或最坏适应算法。
模拟内存的分配和回收过程，观察内存的使用情况和碎片产生的情况。
2、虚拟内存管理了解 Windows 操作系统的虚拟内存机制，通过查看系统性能监视器观察虚拟内存的使用情况。
编写程序来模拟虚拟内存的页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等。
（三）文件系统实验1、文件操作使用 C+＋语言对文件进行创建、读写、删除等操作。
观察文件在磁盘上的存储方式和文件目录的结构。
2、文件系统性能测试对不同大小和类型的文件进行读写操作，测量文件系统的读写性能。
分析影响文件系统性能的因素，如磁盘碎片、缓存机制等。
四、实验结果与分析（一）进程管理实验结果1、创建多个进程在创建多个进程的实验中，通过任务管理器可以观察到每个进程都有独立的进程 ID、CPU 使用率、内存占用等信息。
多个进程可以并发执行，提高了系统的资源利用率。
2、进程同步与互斥在生产者消费者问题的实验中，当使用正确的信号量机制时，生产者和消费者能够协调工作，不会出现数据不一致或死锁的情况。
操作系统实验,实验3, 进程管理 (1)概述
[操作要求1] 设置一个调度，要求5分钟后向用户发送系统即将 重启的消息，并在提示信息出现后的2分钟后重启系统
按组合键[Ctrl+Alt+F1]切换到第一个虚拟终端，以用户名jkx登录；按 组合键[Ctrl+Alt+F2]切换到第二个虚拟终端，以超级用户身份登录字 符界面，以下操作在该终端上完成；
[操作步骤]
在图形界面上利用终端通过命令“su - ”切换到超级用户，编辑文件 “job”；
按组合键[Ctrl+Alt+F2]切换到第二个虚拟终端（超级用户）； 输入命令“at –f job now+1 minute”，设置1分钟后执行at调度内容； 稍等后观察at调度的执行效果，再切换到第一个虚拟终端观察at调度
输入命令“at now+5 minutes”，设置5分钟后执行at调度内容； 在提示符后输入“wall please logout; the computer will restart.”，设
置将要发送的消息； 输入“shutdown +2”或“reboot +2”，设置系统2分钟后重启； [Ctrl+D]结束内容编辑。
[操作步骤]
以普通用户jkx登录，并输入命令“crontab -e”，新建一个 crontab配置文件；
屏幕出现vi编辑器，按[i]键进入输入模式，输入“30 08 * * * ps > ps.log”，然后按[Esc]键退出文本输入模式，并按[:]键切 换到最后行模式，输入“wq”保存退出vi编辑器；
的执行效果；
空闲时执行——batch命令
batch命令用低优先级运行作业
batch [-V] [-q queue] [-f file] [-mv] [time] 该命令与at命令的唯一的区别在于at命令是在指
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三进程管理背景知识Windows所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。
每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。
通常应用程序的框架负责调用ExitProcess() 函数。
对于C++ 运行库来说，这一调用发生在应用程序的main() 函数返回之后。
1. 创建进程CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。
表3-4详细地列出了每个参数的类型和名称。
可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。
然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。
经常使用的标志是CREA TE_SUSPNDED，告诉主线程立刻暂停。
当准备好时，应该使用ResumeThread() API来启动进程。
另一个常用的标志是CREATE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口。
这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。
接着是CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。
第一个参数是lpEnvironment参数，指明为新进程提供的环境；第二个参数是lpCurrentDirectory，可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构所必需的，用于在必要时指明新应用程序的主窗口的外观。
CreateProcess() 的最后一个参数是用于新进程对象及其主线程的句柄和ID的返回值缓冲区。
以PROCESS_INFORMA TION结构中返回的句柄调用CloseHandle() API函数是重要的，因为如果不将这些句柄关闭的话，有可能危及主创进程终止之前的任何未释放的资源。
2. 正在运行的进程如果一个进程拥有至少一个执行线程，则为正在系统中运行的进程。
通常，这种进程使用主线程来指示它的存在。
当主线程结束时，调用ExitProcess() API函数，通知系统终止它所拥有的所有正在运行、准备运行或正在挂起的其他线程。
当进程正在运行时，可以查看它的许多特性，其中少数特性也允许加以修改。
首先可查看的进程特性是系统进程标识符(PID) ，可利用GetCurrentProcessId() API函数来查看，与GetCurrentProcess() 相似，对该函数的调用不能失败，但返回的PID在整个系统中都可使用。
其他的可显示当前进程信息的API函数还有GetStartupInfo()和GetProcessShutdownParameters() ，可给出进程存活期内的配置详情。
通常，一个进程需要它的运行期环境的信息。
例如API函数GetModuleFileName() 和GetCommandLine() ，可以给出用在CreateProcess() 中的参数以启动应用程序。
在创建应用程序时可使用的另一个API函数是IsDebuggerPresent() 。
可利用API函数GetGuiResources() 来查看进程的GUI资源。
此函数既可返回指定进程中的打开的GUI对象的数目，也可返回指定进程中打开的USER对象的数目。
进程的其他性能信息可通过GetProcessIoCounters()、GetProcessPriorityBoost() 、GetProcessTimes() 和GetProcessWorkingSetSize() API得到。
以上这几个API函数都只需要具有PROCESS_QUERY_INFORMA TION访问权限的指向所感兴趣进程的句柄。
另一个可用于进程信息查询的API函数是GetProcessVersion() 。
此函数只需感兴趣进程的PID (进程标识号) 。
本实验程序清单3-6中列出了这一API函数与GetVersionEx() 的共同作用，可确定运行进程的系统的版本号。
3. 终止进程所有进程都是以调用ExitProcess() 或者TerminateProcess() 函数结束的。
但最好使用前者而不要使用后者，因为进程是在完成了它的所有的关闭“职责”之后以正常的终止方式来调用前者的。
而外部进程通常调用后者即突然终止进程的进行，由于关闭时的途径不太正常，有可能引起错误的行为。
TerminateProcess() API函数只要打开带有PROCESS_TERMINATE访问权的进程对象，就可以终止进程，并向系统返回指定的代码。
这是一种“野蛮”的终止进程的方式，但是有时却是需要的。
如果开发人员确实有机会来设计“谋杀”(终止别的进程的进程) 和“受害”进程(被终止的进程) 时，应该创建一个进程间通讯的内核对象——如一个互斥程序——这样一来，“受害”进程只在等待或周期性地测试它是否应该终止。
4.进程同步Windows 2000/XP提供的常用对象可分成三类：核心应用服务、线程同步和线程间通讯。
其中，开发人员可以使用线程同步对象来协调线程和进程的工作，以使其共享信息并执行任务。
此类对象包括互锁数据、临界段、事件、互斥体和信号等。
多线程编程中关键的一步是保护所有的共享资源，工具主要有互锁函数、临界段和互斥体等；另一个实质性部分是协调线程使其完成应用程序的任务，为此，可利用内核中的事件对象和信号。
在进程内或进程间实现线程同步的最方便的方法是使用事件对象，这一组内核对象允许一个线程对其受信状态进行直接控制(见表2-1) 。
而互斥体则是另一个可命名且安全的内核对象，其主要目的是引导对共享资源的访问。
拥有单一访问资源的线程创建互斥体，所有想要访问该资源的线程应该在实际执行操作之前获得互斥体，而在访问结束时立即释放互斥体，以允许下一个等待线程获得互斥体，然后接着进行下去。
与事件对象类似，互斥体容易创建、打开、使用并清除。
利用CreateMutex() API可创建互斥体，创建时还可以指定一个初始的拥有权标志，通过使用这个标志，只有当线程完成了资源的所有的初始化工作时，才允许创建线程释放互斥体。
为了获得互斥体，首先，想要访问调用的线程可使用OpenMutex() API来获得指向对象的句柄；然后，线程将这个句柄提供给一个等待函数。
当内核将互斥体对象发送给等待线程时，就表明该线程获得了互斥体的拥有权。
当线程获得拥有权时，线程控制了对共享资源的访问——必须设法尽快地放弃互斥体。
放弃共享资源时需要在该对象上调用ReleaseMute() API。
然后系统负责将互斥体拥有权传递给下一个等待着的线程(由到达时间决定顺序) 。
1、实验目的1) 通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解Windows进程的“一生”。
2) 通过阅读和分析实验程序，学习创建进程、观察进程、终止进程以及父子进程同步的基本程序设计方法。
2、实验内容和步骤（1）. 创建进程本实验显示了创建子进程的基本框架。
该程序只是再一次地启动自身，显示它的系统进程ID和它在进程列表中的位置。
步骤1：创建一个“Win32 Consol Application”工程，然后拷贝清单2-1中的程序，编译成可执行文件。
步骤2：在“命令提示符”窗口运行步骤1中生成的可执行文件。
运行结果：范例：E:\课程\os课\os实验\程序\os11\debug>os21(假设编译生成的可执行文件是os21.exe)_________E:\q\w\debug\w.exe________________________________________________________________________________ _______________________________________________________________________________ _______________按下ctrl+alt+del，调用windows的任务管理器，记录进程相关的行为属性：_____步骤3：在“命令提示符”窗口加入参数重新运行生成的可执行文件。
运行结果：范例：E:\课程\os课\os实验\程序\os11\debug>os21 3(假设编译生成的可执行文件是os21.exe)_______________________按下ctrl+alt+del，调用windows的任务管理器，记录进程相关的行为属性：________步骤4：修改清单2-1中的程序，将nClone的定义和初始化方法按程序注释中的修改方法进行修改，编译成可执行文件（执行前请先保存已经完成的工作）。
再按步骤2中的方式运行，看看结果会有什么不一样。
运行结果：_________第一次修改___第二次修改_____________________________________________________________________________________ __________________________________________从中你可以得出什么结论：nClone的作用：____设置进程的起始ID号。
__________________________________________________________________________________________________________________________________ 变量的定义和初始化方法（位置）对程序的执行结果有影响吗？为什么？________________ ____答：有影响。
因为变量的定义和初始化的不同可能导致进程的克隆的次数及克隆进程的ID号不同。
（2）. 父子进程的简单通信及终止进程步骤1：创建一个“Win32 Consol Application”工程，然后拷贝清单2-2中的程序，编译成可执行文件。
步骤2：在VC的工具栏单击“Execute Program”(执行程序) 按钮，或者按Ctrl + F5键，或者在“命令提示符”窗口运行步骤1中生成的可执行文件。
运行结果：范例：E:\课程\os课\os实验\程序\os11\debug>os22(假设编译生成的可执行文件是os22.exe)_____________________________________________________________________________________ _______________________________________________________________________________________ _________________________________________________________________步骤3：按源程序中注释中的提示，修改源程序2-2，编译执行（执行前请先保存已经完成的工作）。