深圳大学实验报告课程名称：操作系统
实验项目名称：进程控制
学院：计算机与软件学院
专业：软件工程
指导教师：
报告人：学号：班级：
实验时间：
实验报告提交时间：
教务处制
一、实验目的与要求：
实验目的:通过进程的创建,撤销和运行加深对进程概念和进程并发执行的理解,明确进程与程序之间的区别.
实验要求:
1.掌握在Windows中编程,在CYGWIN中编译运行的方法
2.阅读例程,理解fork(),execl(),exit(),getpid()和waitpid()的功能和用法
3.运行例程,分析例程中关键代码的功能,给出运行结果并对运行结果进行分
析说明.
4.模仿例程,编写一段程序实现以下功能:
a)父进程使用系统调用fork()创建两个子进程
b)各个子进程显示和输出一些提示信息和自己的进程的标识符
c)父进程显示进程的ID和一些提示信息,然后调用waitpid()等待多个子进
程结束,并在子进程结束后显示输出提示信息表示程序结束
5.父进程创建多个(3个以上)进程并发运行,控制好各个子进程输出自己的进
程标识符和一些提示信息,对程序运行结果进行分析说明.观察各个子进程并发执行的顺序,输出的结果是否与设想中的顺序不同,并分析原因.
附加:分析父子进程资源共享的关系,在父进程中定义的变量能否被子进程使用?在特定位置定义才能使用还是所有位置都可以?子进程定义的变量,父进程能否使用?父进程如何强行关闭子进程?
二、方法、步骤：(说明程序相关的算法原理或知识内容，程序设计的思路和方法，可以
用流程图表述，程序主要数据结构的设计、主要函数之间的调用关系等)实验通过fork()函数创建子进程，父进程再通过waitpid()函数调用已创建的子进程，通过父进程和子进程输入自身的标识码来区分正运行的进程是子进程还是父进程。其中，当父进程通过fork()创建一个子进程后，会返回子进程的标识码（PID），而在新建立的子进程中返回0。
三．实验过程及内容：(对程序代码进行说明和分析，越详细越好，代码排版要整齐，可读性要高)
例程2:
#include
#include
#include
#include
#include
#include
#include
int tprintf(const char*fmt,...);
int main()
{
int i=0,j=0;
pid_t pid;
printf("Hello from Parent Process,PID is %d.\n",getpid());
pid = fork();
if(pid == 0)
{
sleep(1);
for(i=0;i<3;i++)
{
printf("Hello from Child Process %d. %d times\n",getpid(),i+1);
sleep(1);
}
}
else if(pid !=-1)
{
tprintf("Part forked one child process--%d.\n",pid);
tprintf("Parent is waiting for child to exit.\n");
waitpid(pid,NULL,0);
tprintf("Child Process has exited.\n");
tprintf("Parent had exited.\n");
}
else tprintf("Everything was done without error.\n");
return 0;
}
int tprintf(const char*fmt,...)
{
va_list args;
struct tm *tstruct;
time_t tsec;
tsec = time(NULL);
tstruct = localtime (&tsec);
printf("%02d:%02d:%02d:%5d",tstruct->tm_hour,tstruct->tm_min,tstruct->tm_sec, getpid());
va_start(args,fmt);
return vprintf(fmt,args);
}
分析: 父进程中首先通过fork()创建了一个子进程，并且返回了子进程的PID，这是的PID 在父进程中不等于0，所以继续运行父进程，当运行到waitpid()时，进入子进程中，开始运行子进程的内容，子进程运行完毕后，返回父进程运行waitpid()后的部分。
例程3:
#include
#include
#include
#include
#include
#include
#include
int tprintf(const char*fmt,...);
int main()
{
int i=0,j=0;
pid_t pid;
printf("Hello from Parent Process,PID is %d.\n",getpid());
pid = fork();
if(pid == 0)
{
sleep(5);
tprintf("Hello from Child Process!\n");
tprintf("I am calling exec.\n");
execl("1","a",NULL);
// execl("1","b","c",NULL);
tprintf("You should never see this because the child is already gone.\n");
}
else if(pid !=-1)
{
tprintf("Hello from Parent , pid %d.\n",pid);
sleep(1);
tprintf("Parent forked process %d.\n",pid);
sleep(1);
tprintf("Parent is waiting for child to exit.\n");
waitpid(pid,NULL,0);
tprintf("Parent had exited.\n");
}
else tprintf("Everything was done without error.\n");
return 0;
}
int tprintf(const char*fmt,...)
{
va_list args;
struct tm *tstruct;
time_t tsec;
tsec = time(NULL);
tstruct = localtime (&tsec);
printf("%02d:%02d:%02d:%5d",tstruct->tm_hour,tstruct->tm_min,tstruct->tm_sec, getpid());
va_start(args,fmt);
return vprintf(fmt,args);
}
分析: 由于在实验室做的例程3的截图丢失，所以我在自己电脑上重新运行且修改了一下execl()函数中的参数。(调用的外部文件是输出“12345”+换行+“45678”)。父进程创建子进程并且进入子进程的过程与例程2相同，子进程中调用execl()函数，执行第一个参数所代表路径的文件并传递第二个参数给该文件。由于子进程中execl()函数成功执行，所以不返回子进程，子进程中在excel()函数后的内容不执行。
四、实验结论：（提供运行结果，对结果进行探讨、分析、评价，并提出结论性意见和改进想法）
例程2:
实验结果截图::
分析: 父进程中首先通过fork()创建了一个子进程，并且返回了子进程的PID，这是的PID 在父进程中不等于0，所以继续运行父进程，当运行到waitpid()时，进入子进程中，开始运行子进程的内容，子进程运行完毕后，返回父进程运行waitpid()后的部分。
建议：先看一下代码，再将运行结果和代码结合起来看更容易理解代码。
例程3:
实验结果截图::
分析:由于在实验室做的例程3的截图丢失，所以我在自己电脑上重新运行且修改了一下execl()函数中的参数。(调用的外部文件是输出“12345”+换行+“45678”)。父进程创建子进程并且进入子进程的过程与例程2相同，子进程中调用execl()函数，执行第一个参数所代表路径的文件并传递第二个参数给该文件。由于子进程中execl()函数成功执行，所以不返回子进程，子进程中在excel()函数后的内容不执行。
建议：创建一个简单的外部文件，子进程调用时容易分辨。(调用的外部文件是输出“12345”+换行+“45678”)。
4.模仿例程,编写一段程序(创建两个子进程)
代码：
#include
#include
#include
#include
#include
#include
#include
int tprintf(const char*fmt,...);
int main()
{
int i=0,j=0;
pid_t pid1;
pid_t pid2;
printf("Hello from Parent Process,PID is %d.\n",getpid());
pid1 = fork();
if(pid1 == 0)
{
sleep(1);
for(i=0;i<3;i++)
{
printf("Hello from Child Process one %d. %d times\n",getpid(),i+1);
sleep(1);
}
}
else if(pid1 !=-1)
{
tprintf("Part forked one child process--%d.\n",pid1);
tprintf("Parent is waiting for child to exit.\n");
waitpid(pid1,NULL,0);
pid2 = fork();
if(pid2 == 0)
{
sleep(1);
for(i=0;i<3;i++)
{
printf("Hello from Child Process two %d. %d times\n",getpid(),i+1);
sleep(1);
}
}
else if(pid2 !=-1)
{
tprintf("Part forked one child process--%d.\n",pid2);
tprintf("Parent is waiting for child to exit.\n");
waitpid(pid2,NULL,0);
tprintf("Child Process has exited.\n");
tprintf("Parent had exited.\n");
}
}
else tprintf("Everything was done without error.\n");
return 0;
}
int tprintf(const char*fmt,...)
{
va_list args;
struct tm *tstruct;
time_t tsec;
tsec = time(NULL);
tstruct = localtime (&tsec);
printf("%02d:%02d:%02d:%5d",tstruct->tm_hour,tstruct->tm_min,tstruct->tm_sec, getpid());
va_start(args,fmt);
return vprintf(fmt,args);
}
运行结果：
分析: 通过父进程创建一个子进程，运行一个子进程，再创建一个子进程，再运行一个子进程的方式，输出各个进程的标识码，可以得到正确的结果。而当两个子进程同时fork()时，会产生3个子进程，这是应为2个fork()放在一起时，会多fork()一个子进程。
5.模仿例程，编写一段程序，父进程创建多个(3个以上)进程并发运行
代码：
#include
#include
#include
#include
#include
#include
#include
int tprintf(const char*fmt,...);
int main()
{
int i=0,j=0;
pid_t pid1;
pid_t pid2;
pid_t pid3;
printf("Hello from Parent Process,PID is %d.\n",getpid());
pid1 = fork();
if(pid1 == 0)
{
sleep(1);
for(i=0;i<3;i++)
{
printf("Hello from Child Process one %d. %d times\n",getpid(),i+1);
sleep(1);
}
exit(0);
}
pid2 = fork();
if(pid2 == 0)
{
sleep(1);
for(i=0;i<3;i++)
{
printf("Hello from Child Process two %d. %d times\n",getpid(),i+1);
sleep(1);
}
exit(0);
}
pid3 = fork();
if(pid3 == 0)
{
sleep(1);
for(i=0;i<3;i++)
{
printf("Hello from Child Process three %d. %d times\n",getpid(),i+1);
sleep(1);
}
exit(0);
}
else if(pid1 !=-1 && pid2 !=-1 && pid3 !=-1)
{
tprintf("Part forked two child process--%d %d %d.\n",pid1,pid2,pid3);
tprintf("Parent is waiting for child to exit.\n");
waitpid(pid1,NULL,0);
waitpid(pid2,NULL,0);
waitpid(pid3,NULL,0);
tprintf("Child Process has exited.\n");
tprintf("Parent had exited.\n");
}
else tprintf("Everything was done without error.\n");
return 0;
}
int tprintf(const char*fmt,...)
{
va_list args;
struct tm *tstruct;
time_t tsec;
tsec = time(NULL);
tstruct = localtime (&tsec);
printf("%02d:%02d:%02d:%5d",tstruct->tm_hour,tstruct->tm_min,tstruct->tm_sec,
getpid());
va_start(args,fmt);
return vprintf(fmt,args);
}
运行结果：
分析:输出结果与想象中不同，首先占用内存的进程不是固定的，并不因为不同waitpid中的PID参数而固定，但是三个子进程会按照第一次运行的顺序继续运行，也就是第一次运行的顺序固定之后，后面的运行顺序不再改变。
五、实验体会：（根据自己情况填写）
注：“指导教师批阅意见”栏请单独放置一页
指导教师批阅意见：
成绩评定：
指导教师签字：
年月日备注：
计算机操作系统进程调度实验研究报告
————————————————————————————————作者：————————————————————————————————日期：
操作系统实验题：设计一若干并发进程的进程调度程序 一、实验目的 无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 二、实验要求 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解． 三、实验内容 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。 四、实验算法流程
实验一、进程控制实验 1.1 实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法，了解父子进程间的控制和协作关系。练习Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。 1.2 实验说明 1）与进程创建、执行有关的系统调用说明进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过exec()系统调用族装入一个新的执行程序。父进程可以使用wait()或waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。 fork()系统调用语法: #include
Exec 执行成功后将用一个新的程序代替原进程，但进程号不变，它绝不会再返回到调用进程了。如果exec 调用失败，它会返回-1。 wait() 系统调用语法: #include
第3章进程描述和控制 复习题： 3.1什么是指令跟踪？ 答：指令跟踪是指为该进程而执行的指令序列。 3.2通常那些事件会导致创建一个进程？ 答：新的批处理作业；交互登录；操作系统因为提供一项服务而创建；由现有的进程派生。（详情请参考表3.1） 3.3对于图3.6中的进程模型，请简单定义每个状态。 答：运行态：该进程正在执行。就绪态：进程做好了准备，只要有机会就开始执行。 阻塞态：进程在某些事件发生前不能执行，如I/O操作完成。新建态：刚刚创建的进程，操作系统还没有把它加入到可执行进程组中。退出态：操作系统从可执行进程组中释放出的进程，或者是因为它自身停止了，或者是因为某种原因被取消。 3.4抢占一个进程是什么意思？ 答：处理器为了执行另外的进程而终止当前正在执行的进程，这就叫进程抢占。 3.5什么是交换，其目的是什么？ 答：交换是指把主存中某个进程的一部分或者全部内容转移到磁盘。当主存中没有处于就绪态的进程时，操作系统就把一个阻塞的进程换出到磁盘中的挂起队列，从而使另一个进程可以进入主存执行。 3.6为什么图3.9（b）中有两个阻塞态？ 答：有两个独立的概念：进程是否在等待一个事件（阻塞与否）以及进程是否已经被换出主存（挂起与否）。为适应这种2*2的组合，需要两个阻塞态和两个挂起态。3.7列出挂起态进程的4个特点。 答：1.进程不能立即执行。2.进程可能是或不是正在等待一个事件。如果是，阻塞条件不依赖于挂起条件，阻塞事件的发生不会使进程立即被执行。3.为了阻止进程执行，可以通过代理把这个进程置于挂起态，代理可以是进程自己，也可以是父进程或操作系统。4.除非代理显式地命令系统进行状态转换，否则进程无法从这个状态中转移。 3.8对于哪类实体，操作系统为了管理它而维护其信息表？ 答：内存、I/O、文件和进程。 3.9列出进程控制块中的三类信息。 答：进程标识，处理器状态信息，进程控制信息。 3.10为什么需要两种模式（用户模式和内核模式）？ 答：用户模式下可以执行的指令和访问的内存区域都受到限制。这是为了防止操作系统受到破坏或者修改。而在内核模式下则没有这些限制，从而使它能够完成其功能。 3.11操作系统创建一个新进程所执行的步骤是什么？ 答：1.给新进程分配一个唯一的进程标识号。2.给进程分配空间。3.初始化进程控制块。 4.设置正确的连接。 5.创建或扩充其他的数据结构。 3.12中断和陷阱有什么区别？ 答：中断与当前正在运行的进程无关的某些类型的外部事件相关，如完成一次I/O操作。陷阱与当前正在运行的进程所产生的错误或异常条件相关，如非法的文件访问。 3.13举出中断的三个例子。 答：时钟终端，I/O终端，内存失效。 3.14模式切换和进程切换有什么区别？ 答：发生模式切换可以不改变当前正处于运行态的进程的状态。发生进程切换时，一个正在执行的进程被中断，操作系统指定另一个进程为运行态。进程切换需要保存更
第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理，以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有：处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件，后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下，计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案： (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案：CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件，是 (2) 的接口。 在处理机管理中，进程是一个重要的概念，它由程序块、 (3) 和数据块三部 分组成，它有3种基本状态，不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间，它通常使用 (5) 作为它的一个主要组成部分。 供选答案： (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案：CDADB 3.在计算机系统中，允许多个程序同时进入内存并运行，这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
第二章作业 1.操作系统中为什么要引入进程的概念？为了实现并发进程中的合作和协调，以及保证系统的安全，操作系统在进程管理方面要做哪些工作？ 答：为了从变化角度动态地分析研究可以并发执行的程序，真实的反应系统的独立性、并发性、动态性和相互制约，操作系统中不得不引入进程的概念。 为了防止操作系统及其关键的数据结构如：PCB等，受到用户程序破坏，将处理机分为核心态和用户态。对进程进行创建、撤销以及在某些进程状态之间的转换控制。 2.试描述当前正在运行的进程状态改变时，操作系统进行进程切换的步骤。答：分为两种情况： （1）：运行状态就绪状态：根据进程的自身的情况插入到就绪队列的适当位置，系统收回处理及转入进程调度程序重新进行调度。 （2）：运行状态→阻塞状态：系统会调用进程调度程序重新选择一个进程投入运行。 3.现代操作系统一般都提供多任务的环境，是回答以下问题。 为支持多进程的并发执行，系统必须建立哪些关于进程的数据结构？ 答：系统必须建立PCB。 为支持进程的状态变迁，系统至少应该供哪些进程控制原语？ 答：阻塞、唤醒、挂起和激活原语。 当进程的状态变迁时，相应的数据结构发生变化吗？ 答：会根据状态的变迁发生相应的变化。例如：将进程PCB中进程的状态从阻塞状态改为就绪状态，并将进程从阻塞队列摘下，投入到就绪队列中。 4.什么是进程控制块？从进程管理、中断处理、进程通信、文件管理、设备管理及存储管理的角度设计进程控制块应该包含的内容。 答：PCB：描述进程本身的特征、状态、调度信息以及对资源占有情况等的数据结构，是进程存在的唯一标识。 进程控制块所包含的内容： ①进程信息描述；②CPU信息状态；③进程调度信息；④进程控制和资源占用信息。 5.假设系统就绪队列中有10个进程，这10个进程轮换执行，每隔300ms轮换一次，CPU在进程切换时所花费的时间是10ms，试问系统化在进程切换上的开销占系统整个时间的比例是多少？ 解：P=(10*10)/[(300+10)*10]=3.2% 6.试述线程的特点及其与进程之间的关系。 答：线程的特点：是被独立分派和调度的基本单位。线程与进程的关系：线程是进程的一部分，是进程内的一个实体；一个进程可以有多个线程，但至少必须有一个线程。
操作系统实验报告 2012年12月19 日 一、实验内容 1、自定义进程相关的数据结构； 2、利用MFC类库中的栈(queue)，链表(list)，向量(vector)等模板模拟进程控制块队列、进 程控制块优先级队列、统计信息链表及其指令集合； 3、利用MSDN和MFC API编程实现常见的进程控制和调度策略（先来先服务算法、时间 片轮转算法、最高优先权优先调度算法、最短进程优先调度算法）； 4、测试以上进程调度策略的周转时间、带权周转时间、平均周转时间和平均带权周转时间，并定性评价它们的性能。 二、实验要求 用高级语言编写和调试进程调度的模拟程序，以加深对进程调度算法的理解。 三、实验步骤 typedef struct PCBNode { int ID; int Priority; int CPUtime; int Alltime; int Arrivetime; int state; int counter; struct PCBNode *next; }PCB;//定义数据结构 PCB *run; PCB *ready; PCB *over; PCB *head; //定义状态量 int Min(PCB *head)//挑选出队列中的拥有最小alltime 值的块，返回块号,用于sjf 算法 { PCB *p;//q用来记录这个块的地址 int min,id;//记录最小值和块号 p=head->next; if(p) { min=p->Alltime; id=p->ID;
while(p->next) { if(min>p->next->Alltime) { min=p->next->Alltime; id=p->next->ID; p=p->next; } else { p=p->next; } } } return id; } int Max(PCB *head)//挑选出队列中的拥有最大优先级的块，返回块号，用于prio 算法 { PCB *p;//q用来记录这个块的地址 int max,id;//记录最大和块号 p=head->next; if(p) { max=p->Priority; id=p->ID; while(p->next) { if(max<=p->next->Priority) { max=p->next->Priority; id=p->next->ID; p=p->next; } else { p=p->next; } } } return id; } PCB *CreatPCB(int n) {
第二章操作系统进程(练习题答案)
————————————————————————————————作者：————————————————————————————————日期： 2
第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理，以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有：处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件，后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下，计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案： (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案：CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件，是 (2) 的接口。 在处理机管理中，进程是一个重要的概念，它由程序块、 (3) 和数据块三部 分组成，它有3种基本状态，不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间，它通常使用 (5) 作为它的一个主要组成部分。 供选答案： (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案：CDADB 3.在计算机系统中，允许多个程序同时进入内存并运行，这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。
实验一、进程控制实验 实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法，了解父子进程间的控制和协作关系。练习Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。 实验说明 1）与进程创建、执行有关的系统调用说明进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过exec()系统调用族装入一个新的执行程序。父进程可以使用wait()或waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。 fork()系统调用语法: #include <> pid_t fork(void); fork 成功创建子进程后将返回子进程的进程号,不成功会返回-1. exec 系统调用有一组6 个函数,其中示例实验中引用了execve 系统调用语法: #include <> int execve(const char *path, const char *argv[], const char * envp[]); path 要装入的新的执行文件的绝对路径名字符串. argv[] 要传递给新执行程序的完整的命令参数列表(可以为空). envp[] 要传递给新执行程序的完整的环境变量参数列表(可以为空). Exec 执行成功后将用一个新的程序代替原进程，但进程号不变，它绝不会再返回到调用进程了。如果exec 调用失败，它会返回-1。 wait() 系统调用语法: #include
实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的sched.h源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码如下： #include
else{ pid2 = fork(); if(pid2<0){ fprintf(stderr,"childprocess1 failed"); exit(-1); } else if(pid2 == 0){ printf("c\n"); } else{ printf("a\n"); sleep(2); exit(0); } } return 0; } 结果如下： 分析原因： pid=fork(); 操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！因此，这三个进程哪个先执行，哪个后执行，完全取决于操作系统的调度，没有固定的顺序。 （2）进程的控制 修改已经编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 将父进程的输出改为father process completed 2/11
操作系统课程设计实验报告 实验名称：进程控制 姓名/学号：xx 20091758 一、实验目的 设计并实现Unix的“time”命令。“mytime”命令通过命令行参数接受要运行的程序，创建一个独立的进程来运行该程序，并记录程序运行的时间。 二、实验内容 一、在Windows下实现: ?使用CreateProcess()来创建进程 ?使用WaitForSingleObject()在“mytime”命令和新创建的进程之间同步 ?调用GetSystemTime()来获取时间 在Linux下实现: ?使用fork()/execv()来创建进程运行程序 ?使用wait()等待新创建的进程结束 ?调用gettimeofday()来获取时间 mytime的用法： $ mytime.exe program1 三、实验环境 操作系统：Windows7旗舰版 处理器：Intel Core2 Duo p7450 2.13GHz 内存：2.00GB 32位操作系统 LINUX版本信息：Linux ubuntu 2.6.32-21-generic #32-Ubuntu SMP Fri Apr 16 08:10:02 UTC 2010 i686 GNU/Linux
四、程序设计与实现 一.windows下的实验 1、创建进程之前先用系统函数getsystemtime获取当前时间。 SYSTEMTIME systime; GetSystemTime(&systime); 2、调用createprocess函数创建进程： BOOL bRet = CreateProcess( NULL, //不在此指定可执行文件的文件名 argv[1], //命令行参数 NULL, //默认进程安全性 NULL, //默认线程安全性 FALSE, //当前进程内的句柄不可以被子进程继承 CREATE_NEW_CONSOLE, //为新进程创建一个新的控制台窗口 NULL, //使用本进程的环境变量 NULL, //使用本进程的驱动器和目录 &si, //父进程传给子进程的一些信息 &pi); //保存新进程信息的结构 由于要使用命令行来创建进程，，所以我的createprocess函数第一个参数设置为NULL，通过第二个参数在命令行里实现创建进程。 3、使用等待函数来等待所创建进程的死亡。 WaitForSingleObject(pi.hProcess,INFINITE); 4、再次取得系统当前时间，与上次取得时间作差，得到进程运行时间。 具体做法是：将两次时间对应位作差，然后换算成相应秒数。 t=(systime.wHour-h)*3600+(systime.wMinute-m)*60+systime.wSecond-s+(systime.w Milliseconds-ms)/1000; 二．Linux下的实验 1、创建进程之前先得到系统时间 struct timeval start; struct timeval end; gettimeofday(&start,NULL); 2、用fork函数创建进程，这时函数会返回两个值，需要通过返回值来判断是子进程还 是父进程。 pc = fork(); if ( pc < 0 ) /* 如果出错*/ { exit(1); } else if ( pc == 0) /* 如果是子进程*/ {……} else /* 如果是父进程*/ {……}
操作系统实验实验二进程管理 学号 1215108019 姓名克帆 学院信息学院 班级 12电子2
实验目的 1、理解进程的概念，明确进程和程序的区别。 2、理解并发执行的实质。 3、掌握进程的创建、睡眠、撤销等进程控制方法。 实验容与要求 基本要求：用C语言编写程序，模拟实现创建新的进程；查看运行进程；换出某个进程；杀死进程等功能。 实验报告容 1、进程、进程控制块等的基本原理。 进程是现代操作系统中的一个最基本也是最重要的概念，掌握这个概念对于理解操作系统实质，分析、设计操作系统都有其非常重要的意义。为了强调进程的并发性和动态性，可以给进程作如下定义：进程是可并发执行的程序在一个数据集合上的运行过程，是系统进行资源分配和调度的一个独立单位。 进程又就绪、执行、阻塞三种基本状态，三者的变迁图如下： 由于多个程序并发执行，各程序需要轮流使用CPU，当某程序不在CPU上运行时，必须保留其被中断的程序的现场，包括：断点地址、程序状态字、通用寄存器的容、堆栈容、程序当前状态、程序的大小、运行时间等信息，以便程序再次获得CPU时，能够正确执行。为了保存这些容，需要建立—个专用数据结构，我们称这个数据结构为进程控制块PCB （Process Control Block）。 进程控制块是进程存在的惟一标志，它跟踪程序执行的情况，表明了进程在当前时刻的状态以及与其它进程和资源的关系。当创建一个进程时，实际上就是为其建立一个进程控制块。 在通常的操作系统中，PCB应包含如下一些信息： ①进程标识信息。为了标识系统中的各个进程，每个进程必须有惟一的标识名或标 识数。 ②位置信息。指出进程的程序和数据部分在存或外存中的物理位置。 ③状态信息。指出进程当前所处的状态，作为进程调度、分配CPU的依据。 ④进程的优先级。一般根据进程的轻重缓急其它信息。 这里给出的只是一般操作系统中PCB所应具有的容，不同操作系统的PCB结构是不同的，我们将在2.8节介绍Linux系统的PCB结构。
操作系统进程管理实验 实验题目： （1）进程的创建编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 （2）进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。 （3）编制一段程序，使其实现进程的软中断通信。要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程调用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止：Parent process is killed! 在上面的程序中增加语句signal(SIGINT, SIG_IGN)和signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。 （4）进程的管道通信编制一段程序，实现进程的管道通信。使用系统调用pipe( )建立一条管道线；两个进程P1和P2分别向管道各写一句话：Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。 实验源程序及报告： （1）、进程的创建 #include
习题集 - 2 - 进程管理 1. 在优先级调度中，__________类进程可能被“饿死”，即长时间得不到调度。 A．短进程 B．长进程 C．低优先级进程 D．大内存进程 解： C。优先级调度算法（PRI）的基本思想是：内核为每个进程赋予一个优先级，进程按照优先级的大小顺序在就绪队列中排队，内核将CPU分配给就绪队列头部的第一个进程——优先级最大的进程。因此，进程的优先级越低，在就绪队列中的排队位置就越靠近队列尾，获得运行之前的等待时间就越长。低优先级的进程必须等待所有高优先级进程运行结束后才会被调度运行。如果不断有高优先级的进程加入就绪队列，那么低优先级进程就会一直等待下去。这就是所谓的“饿死”现象。 2. 在下面的系统调用中，__________不会导致进程阻塞。 A．读/写文件 B．获得进程PID C．申请内存 D．发送消息 解： B。当正在执行的进程需要使用某种资源或等待某个事件时，如果资源已被其他进程占用或事件尚未出现，该进程不能获得所需的资源而无法继续运行，于是，进程将被阻塞。进程在阻塞状态中等待资源被释放，或等待事件的发生。所以，进程在执行系统调用时，如果需要使用某种资源，就可能导致进程阻塞。“读/写文件”需要使用设备和文件缓冲区；“申请内存”需要分配内存资源；“发送消息”需要使用消息缓冲区。 3. 下面关于临界区的叙述中，正确的是__________ A．临界区可以允许规定数目的多个进程同时执行 B．临界区只包含一个程序段 C．临界区是必须互斥地执行的程序段 D．临界区的执行不能被中断 解： C。临界段（临界区）的概念包括两个部分：①临界资源：必须互斥访问的资源。例如，需要独占使用的硬件资源，多个进程共享的变量、结构、队列、栈、文件等软件资源。②临界区：访问临界资源的、必须互斥地执行的程序段。即，当一个进程在某个临界段中执行时，其他进程不能进入相同临界资源的任何临界段。
实验三操作系统进程管理 一、实验目的 1) 掌握系统进程的概念，加深对Linux / UNIX进程管理的理解。 2) 学会使用ps命令和选项。 3) 列出当前shell中的进程。 4) 列出运行在系统中的所有进程。 5) 根据命令名搜索特定的进程。 6) 使用kill命令终止进程。 7) 根据用户名查找和终止进程。 二、实验内容和相应的答案截图，三、实验结果分析 步骤1：创建一个普通用户（参见实验二），以普通用户身份登录进入GNOME。 步骤2：打开一个“终端”窗口（参见实验二）。 步骤3：回顾系统进程概念，完成以下填空： 1) Linux系统中，几乎每一个启动的进程，都会由内核分配一个唯一的__PID__进程标识符，用于跟踪从进程启动到进程结束。 2) 当启动新进程的时候，内核也给它们分配系统资源，如__内存_和__CPU_。 3) 永远不向父进程返回输出的进程叫做__僵进程__。 4) 由父进程派生出来的进程叫做____子___进程。 5) ___父_进程是一个派生另一个进程的进程。 6) 运行用于提供服务的Linux系统进程是_______________。 7) 如果父进程在子进程之前结束，它创建了一个______________进程。 步骤4：回顾ps命令和信息。基本的ps命令显示当前shell中的进程信息，用户只能够查看当前终端窗口中初始化的进程。输入ps命令，将结果填入表3-3中。 表3-3 实验记录 下面，在当前终端窗口中，练习使用给出的每个选项的ps命令。
输入ps -f 命令，显示运行在系统中的某个进程的完全信息，填入表3-4中。 表3-4 实验记录 步骤5：列出系统中运行的所有进程。 输入ps -ef 命令，显示运行在系统中的各个进程的完全信息。执行该命令，并与ps –f 命令的输出结果对照，一致吗？有何不同？ 答：不一致，后者显示了所有进程的完全可用信息，多了很多。 分析当前终端窗口中的输出结果，记录下来用于写实验报告。 a. 显示了多少个进程？答：59 b. 进程ID的PID是什么？ c. 启动进程的命令(CMD) 是什么？答：sched d. 请观察，什么命令的PID号是1？答：init[5] e. 执行ps –ef >aaa命令，将ps命令的输出送到文本文件aaa。再次运行cat aaa | wc命令，计算进程的数目。其中，cat是显示文本文件命令。“|”是管道命令，就是将前一个命令的输出作为后一个命令的输入。wc 命令用来计算文本的行数，第一个数字显示的是行的数目，可以用来计算进程的数目。计算出进程数目并做记录。 执行man ps命令，可以打开Linux用户命令手册。了解ps命令的用法。输入wq命令可退出用户手册的阅读。man命令可以执行吗？结果如何？ 答：Man ps时出现
WINDOWS系列操作系统常见进程列表（精华） 下面是系统的进程列表 最基本的系统进程（也就是说，这些进程是系统运行的基本条件，有了这些进程，系统就能正常运行） smss.exe session manager csrss.exe 子系统服务器进程 winlogon.exe 管理用户登录 services.exe 包含很多系统服务 lsass.exe 管理 ip 安全策略以及启动 isakmp/oakley (ike) 和 ip 安全驱动程序。(系统服务) 产生会话密钥以及授予用于交互式客户/服务器验证的服务凭据(ticket)。(系统服务) svchost.exe 包含很多系统服务 svchost.exe spoolsv.exe 将文件加载到内存中以便迟后打印。(系统服务) explorer.exe 资源管理器 internat.exe 托盘区的拼音图标 附加的系统进程（这些进程不是必要的，你可以根据需要通过服务管理器来增加或减少） mstask.exe 允许程序在指定时间运行。(系统服务) regsvc.exe 允许远程注册表操作。(系统服务) winmgmt.exe 提供系统管理信息(系统服务)。 inetinfo.exe 通过 internet 信息服务的管理单元提供 ftp 连接和管理。(系统服务) tlntsvr.exe 允许远程用户登录到系统并且使用命令行运行控制台程序。(系统服务) 允许通过 internet 信息服务的管理单元管理 web 和 ftp 服务。(系统服务) tftpd.exe 实现 tftp internet 标准。该标准不要求用户名和密码。远程安装服务 的一部分。(系统服务) termsrv.exe 提供多会话环境允许客户端设备访问虚拟的 windows 2000 professional 桌面会话以及运行在服务器上的基于 windows 的程序。(系统服务) dns.exe 应答对域名系统(dns)名称的查询和更新请求。(系统服务) 以下服务很少会用到，上面的服务都对安全有害，如果不是必要的应该关掉 tcpsvcs.exe 提供在 pxe 可远程启动客户计算机上远程安装 windows 2000 professional 的能力。(系统服务) 支持以下 tcp/ip 服务：character generator, daytime, discard, echo, 以及 quote of the day。(系统服务) ismserv.exe 允许在 windows advanced server 站点间发送和接收消息。(系统服 务) ups.exe 管理连接到计算机的不间断电源(ups)。(系统服务) wins.exe 为注册和解析 netbios 型名称的 tcp/ip 客户提供 netbios 名称服务。(系统服务)
操作系统进程控制实验报告 硬件环境：处理器：Intel(R) Core(TM) i5-3210M CPU @2.50GHz 2.50GHz 安装内存：4.00GB 系统类型：64位操作系统 软件环境：Linux系统 一、实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法，了解父子进程间的控制和协作关系。练习Linux系统中进程创建与控制有关的系统调用的编程和调试技术。 二、实验步骤 （1）分析实例实验 （2）进行独立实验 （3）思考并完成实验报告 实验截图：
思考： 说明它们反映出操作系统教材中进程及处理机管理一节讲解的进程的哪些特征和功能？在真实的操作系统中它是怎样实现和反映出教材中讲解的进程的生命期、进程的实体和进程状态控制的。你对于进程概念和并发概念有哪些新的理解和认识？子进程是如何创建和执行新程序的？信号的机理是什么？怎样利用信号实现进程控制？根据实验程序、调试过程和结果分析写出实验报告。 1.进程的概念：进程不仅是一段程序代码，还包括当前活动(通过程序计数器和寄存器中的内容来表示)，另外，进程还包括进程堆栈段，和数据段等。 2.并发概念：是指进程之间交替并发执行 3.进程通过系统调用fork（）函数创建子进程，子进程由唯一的pid
值标示，pid通常是一个整数值。通过fork创建的子进程实际上是父进程的克隆体，通过复制原来进程的地址空间而成，父子进程同时执行fork之后的程序。但是父子进程的pid值不同，可以通过对pid的判断，使父子进程执行不同的程序。子进程如果想执行不同的程序，需要系统调用exec（）函数装入新的程序执行。 4.信号的机理：信号是用来通知进程某个特定的事件已经发生。信号是由特定的事件产生，信号必须要发送到进程，一旦发送，进程必须得到处理。信号可以可以有系统默认处理也可以用户自定义处理。 5.如何通过信号控制程序：每个进程都有信号机制检验是否有信号到达，如果有，捕获信号后，根据系统默认处理或者用户自定义的防方法处理信号，当信号处理完后，在返回原来的程序继续执行。 代码： pctl.c: #include "pctl.h" int main(int argc, char *argv[]) { int m=2; int i; int seconds=3; int pid1; int pid2; //存放子进程号 int status1; int status2; //存放子进程返回状态 char *args1[] = {"/bin/ls","-all",NULL}; //子进程1要缺省执行的命令 char *args2[] = {"/bin/ps","-l",NULL}; //子进程2要缺省执行的命令 signal(SIGINT,(sighandler_t)sigcat); //注册一个本进程处理键盘中断的函数 while(m!=0)