进程管理系统操作系统
题 目 进程管理系统 摘 要
随着我国国民经济建设的蓬勃发展和具有中国特色的社会主义市场经济体制的迅速完善，各个行业都在积极使用现代化的管理工具，不断改善企业的服务质量，提高工作效率。无论是行政职能，还是生产运作的管理要求的不断提高，在很大程度上使企业不得不改变传统的经营管理方式以适应快速发展的社会主义市场经济，改变企业管理方式、方法已经成为企业发展的先决条件。建设一个科学高效的进程管理系统是解决这
一问题的必由之路。
本文系统根据操作系统理论课上学习的操作系统中关于进程管理实现方法，，包括：进程管理主要包括进程调度，进程的创建和撤销、进程的阻塞和唤醒。本论文主要分为四个部分，引言与结束部分稍略，系统分析与设计主要阐述系统的主要功能模块以及每个模块计划采用的实现方法和原理；系统实现部分，主要通过流程图等工具描述主要模块的实现流程。
关键词：进程调度；进程的创建和撤销；进程的阻塞和唤醒
装 订 线
The title
Process management system
ABSTRACT
With the vigorous develop,ment of our national economy construction and the rapid improvement of the socialist market economic system with Chinese characteristics all industries are actively using modern management tools, continuously improve the service quality of enterprises, improve work efficiency. No matter administrative function or the continuous improvement of the management requirements of production operations,
make the enterprise have to change the traditional way of management in order to adapt to the fast developing socialist market economy, change business management, the method has
already become the prerequisite of the enterprise development. Building a scientific and efficient process management system is the only way to solve this problem.
This paper is based on the theory of operating system that learning process management, implementation , Including: process management, including process scheduling, process creation and revocation, blocked and awakened processes. This paper is divided into four parts, the introduction and the closing part are slightly better, system analysis and design, mainly describes the main functional modules of the system and the implementation method and principle of each module plan ; System implementation section, It mainly describes the flow chart of main modules through flow chart and other tools.
Keywords: process scheduling ；process creation and revocation ；process blocking and wakeup
装 订 线
题目 ....................................................................................................................................... 1 摘要 ....................................................................................................................................... 1 １ 引言 . (4)
1.1 设计目的 ........................................................................................................ 4 1.2 任务和要求 (4)
２ 总体设计 ................................................................................................................. 5 ３ 进程控制 .. (6)
3.1 阻塞进程 (6)
3.2 唤醒进程 ........................................................................................................ 6 3.3 创建进程 .. (7)
４ 进程调度 (9)
4.1 判断等待队列是否有进程在等待进就绪队列 ............................ 9 4.2 判断后备队列进程能否进入就绪队列 ......................................... 10 4.3 就绪队列中先来的进程进入ＣＰＵ运行 .................................... 10 4.4 时间片到了，ＣＰＵ上的进程转到就绪队列或完成队列 11
５ 调试与测试 ......................................................................................................... 13 总结 . (16)
参考文献 .......................................................................................................................... 17 致谢...................................................................................................................................... 18 附录 . (19)
装 订 线
1.1 设计目的：
通过模拟操作系统原理的实现，加深对操作系统工作原理和操作系统实现方法的理解；通过模拟操作系统原理的实现练习编程。
1.2 任务和要求
1、良好的沟通和合作能力
2、充分利用课上所学的操作系统、程序设计、数据结构等相关知识
3、充分利用调试和排错技术
4、简单测试驱动模块和桩模块的编写
5、查阅相关资料，自学具体课题中涉及的新知识
6、课题完成后必须按要求提交课程设计报告，格式规范，内容详实
装
订
线
2 总体设计
为作业创建进程，撤销已结束的进程，以及控制进程在运行过程中的状态转换。 进程的状态转换：
进程创建的主要工作是： 第一步，申请空白进程控制块； 第二步，程序装入pcb//内存申请； 第三步，初始化进程控制块； 第四部，将进程链入就绪队列。
进程撤销的主要工作是： 第一步，将结果写入out 文件； 第二步，回收进程控制块；
装 订 线
3 进程控制
3.1 阻塞进程
正在执行的进程当出现某个事件时，使其无法继续执行，进程将通过调用阻塞原语把自己阻塞。进程阻塞是进程自身的一种主动行为。
进入block 过程后，由于此时刻进程处于执行状态，所以应先立即停止执行。把进程控制块中的现行状态由执行改为阻塞并将其插入到阻塞队列中。
代码如下：
else if (source == suspendBtn) //阻塞进程 { System.out .println("点击阻塞" ); if (!CPUTf.getText().equals("")) { CPUToWLbl.setForeground(Color.RED );
CPUTf.setText(""); CPUProcessId = "";
waitingLm.addElement(CPUProcess); System.out .println("阻塞成功" ); try { sleep (500);
}
catch (Exception e) { }
CPUToWLbl.setForeground(Color.BLACK );
}
}
3.2 唤醒进程
当I/O 操作完成或其期待的数据已到达，则由有关进程调用唤醒原语将等待该事件的进程唤醒。
代码如下：
else if (source == unsuspendBtn) //唤醒进程 {
System.out .println("点击唤醒" );
String unsuspendProcess = "";
装 订 线
if (waitingList.getSelectedValue()!= null )
{ unsuspendProcess = waitingList.getSelectedValue().toString();
waitingReadyV .add(unsuspendProcess);
warningLbl.setText(""); System.out .println("唤醒成功" );
} else { warningLbl.setText("请选择要唤醒的进程"); }
}
3.3 创建进程
一旦操作系统发现了要求创建新进程的事件后，便调用进程创建原语，按照申请空
白进程控制块，为新进程分配资源，初始化进程控制块。将新进程插入就绪队列的步骤，从而创建一个新进程。
代码如下：
//创建新的进程函数 int create() {
int i= 0; if(shumu>20) {
printf("内存已满请先换出进程!\n"); i = -1; return i; } else {
if(jiuxu==NULL) //如果就绪队列中没有进程的话 {
p=(Jincheng*)malloc(sizeof(Jincheng)); printf("请输入新进程的名字（数字）:\n"); scanf("%d",&p->pid);
printf("请输入新进程的优先级:（数字）\n"); scanf("%d",&p->youxian); p->luntime=3.5; p->zhantime=3;
装 订 线
printf("请输入进程内容：\n");
p->neirong=(Node*)malloc(sizeof(Node)); scanf("%s",p->neirong->a); // p->neirong=NULL;
p->zhuangtai='b'; //新建进程的状态设置为“就绪” p->next=NULL; jiuxu=p; shumu++; i=1; }
else //如果就绪队列不是空队列 {
p=jiuxu;
while(p->next!=NULL) {
p=p->next; //p 一直指向就绪队列的队尾 }
q=(Jincheng*)malloc(sizeof(Jincheng)); q->next=NULL;
p->next=q; //在就绪队列的队尾加入新建的进程 printf("请输入新进程的名字（数字）:\n"); scanf("%d",&q->pid);
printf("请输入新进程的优先级:（数字）\n"); scanf("%d",&q->youxian); q->luntime=3.5; q->zhantime=3;
printf("请输入进程内容：\n");
q->neirong=(Node*)malloc(sizeof(Node)); scanf("%s",q->neirong->a); //q->neirong=NULL;
q->zhuangtai='b'; //新建进程的状态设置为就绪 shumu++; i=1; } } return i; }
装 订 线
4 进程调度
4.1 判断是否有进程在等待进程就绪队列：
代码如下：
if(jiuxu==NULL) //如果就绪队列中没有进程的话 {
p=(Jincheng*)malloc(sizeof(Jincheng)); printf("请输入新进程的名字（数字）:\n"); scanf("%d",&p->pid);
printf("请输入新进程的优先级:（数字）\n"); scanf("%d",&p->youxian); p->luntime=3.5; p->zhantime=3;
printf("请输入进程内容：\n");
p->neirong=(Node*)malloc(sizeof(Node));
scanf("%s",p->neirong->a); // p->neirong=NULL;
p->zhuangtai='b'; //新建进程的状态设置为“就绪” p->next=NULL; jiuxu=p; shumu++; i=1; }
else //如果就绪队列不是空队列 {
p=jiuxu;
while(p->next!=NULL) {
p=p->next; //p 一直指向就绪队列的队尾 }
q=(Jincheng*)malloc(sizeof(Jincheng)); q->next=NULL;
p->next=q; //在就绪队列的队尾加入新建的进程 printf("请输入新进程的名字（数字）:\n"); scanf("%d",&q->pid);
printf("请输入新进程的优先级:（数字）\n"); scanf("%d",&q->youxian); q->luntime=3.5; q->zhantime=3;
printf("请输入进程内容：\n");
q->neirong=(Node*)malloc(sizeof(Node));
装 订 线
scanf("%s",q->neirong->a); //q->neirong=NULL;
q->zhuangtai='b'; //新建进程的状态设置为就绪
shumu++; i=1; } } return i; }
4.2 判断后备队列进程能否进就绪队列：
代码如下：
while (readyLm.size()<4 && !reserveLm.isEmpty()) {
readyLm.addElement(reserveLm.getElementAt(0));//getElementAt(0)返回指定索引处0 rToRLbl.setForeground(Color.RED ); this.sleep (500);
rToRLbl.setForeground(Color.BLACK ); reserveLm.removeElementAt(0); }
4.3 就绪队列中先来的进程进入CPU 运行：
代码如下：
i nt bijiao()
{ int i,j; p=jiuxu;
while(p->next!=NULL) {
p=p->next; }
q=p; //q 指向进程的末尾，即新建的进程 i=q->youxian; //i 代表新建进程的优先级
j=yunxing->next->youxian; //j 代表正在执行进程的优先级
if(i>j) //如果新建的进程的优先级高于正在执行程序的优先级 {
p=jiuxu;
if(p==q) //就绪队列的进程中只有一个进程。也就是那个新建的进程 {
jiuxu->next=yunxing->next; yunxing->next=jiuxu;
装 订 线
return 1; }
else{ while(p->next!=q) {
p=p->next;
} //执行完后 p 指针在 q 指针前面
p->next=yunxing->next; //将正在执行的进程放置p 的后面 yunxing->next=q; //将q 放置在正在执行列表中，把处理机交给优先级高级的进程 p->next->next=q->next; yunxing->next->next=NULL; return 1; } }
else return -1; }
4.4 时间片到了，CPU 上的进程转到就绪队列或完成队列：
代码如下：
//换出进程函数 void huanchu(int a) {
p=jiuxu;
while(p->pid!=a&&p!=NULL) { q=p; p=p->next; }
if(p==NULL) {
printf("该进程不在内存里!\n"); return; }
if(p==jiuxu) {
q=yunxing->next; yunxing->next=jiuxu;
装 订 线
}
else
{
q->next=yunxing->next;
q->next->next=p->next;
yunxing->next=p;
}
}
//杀死正在运行进程函数
void shasi()
{
yunxing->next=NULL;
printf("运行的进程已经杀死!\n");
return;
}
装
订
线
5 调试与测试
1、 进程创建：
（1）时间片为5，首先创建一个运行时间为1的进程：
（2）再创建一个运行时间为2，3的进程：
装 订 线
（3）运行中间结果，可以看到进程读完时间片后重返就绪队列：
2、 进程堵塞：
在其运行过程中手动点击进程堵塞按钮使其强制进入堵塞队列：
装 订 线
3、进程唤醒：
（1）对5.2中的堵塞进程，选中并点击进程唤醒按钮，放入就绪队列
（2）运行结果如下：
装
订
线
总结
本次实验，我的任务是模拟一个进程管理的系统，该系统包括硬件工作的模拟、模拟中断的种类和中断处理方式、进程控制等，从而观察诸进程的运行过程，虽然不能
尽善尽美，但也基本可以实现老师的要求。
几个学期的程序设计课程，虽然时间不长，但是我自己也收获了很多，这次试验，加深了我对进程概念及进程管理的理解；比较熟悉进程管理中主要数据结构的设计及进
程调度算法、进程控制机构等。也让我认识到自己的不足，操作系统的有些知识，还没
有很好的掌握好，还需要多多学习，不断提升自己的能力。
装
订
线
参考文献
（1）袁方、王亮编著《C++程序设计》。出版地：北京。出版单位：清华大学出版社。出版年月：2013年4月。
（2）刘振鹏、王煜、张明编著《操作系统（第三版）》。出版地：北京。出版单位：中国铁道出版社。出版年月：2010年7月第三版。
（3）叶和亚编著《Java程序设计使用教程》。出版地：北京。出版单位：电子工业出版社。出版年月：2010年2月。
装
订
线
致谢
非常感谢张明老师和李宏同学，正是因为张明老师的指导和李宏同学的帮助，我才顺利完成操作系统课程设计，接下来的日子里我会更加努力学习，以求设计更加完善。
装
订
线
附 录
#include
char a[20]; //int a; // char ch; };
typedef struct node Node;
//进程PCB 结构体 struct jincheng {
int pid; int youxian; float luntime; float zhantime;
char zhuangtai; //a 表示执行，b 表示动态就绪 Node *neirong; struct jincheng *next; };
typedef struct jincheng Jincheng;
Jincheng *jiuxu,*yunxing,*p,*q;
//换出进程函数 void huanchu(int a) {
p=jiuxu;
while(p->pid!=a&&p!=NULL) { q=p; p=p->next; }
if(p==NULL)
装 订 线
{
printf("该进程不在内存里!\n"); return; }
if(p==jiuxu) {
q=yunxing->next; yunxing->next=jiuxu; q->next=jiuxu->next; jiuxu=q; } else {
q->next=yunxing->next; q->next->next=p->next; yunxing->next=p; } }
//杀死正在运行进程函数 void shasi() {
yunxing->next=NULL;
printf("运行的进程已经杀死!\n"); return; }
//创建新进程后与正在运行进程比较优先级并根据优先级判断谁该占用处理机 int bijiao() { int i,j; p=jiuxu;
while(p->next!=NULL) {
p=p->next; }
q=p; //q 指向进程的末尾，即新建的进程 i=q->youxian; //i 代表新建进程的优先级
j=yunxing->next->youxian; //j 代表正在执行进程的优先级
if(i>j) //如果新建的进程的优先级高于正在执行程序的优先级 {
p=jiuxu;
装 订 线
计算机操作系统进程调度实验研究报告
计算机操作系统进程调度实验研究报告
————————————————————————————————作者：————————————————————————————————日期：
操作系统实验题：设计一若干并发进程的进程调度程序 一、实验目的 无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 二、实验要求 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解． 三、实验内容 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。 每个进程有一个进程控制块（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章进程描述和控制 复习题： 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。临界段（临界区）的概念包括两个部分：①临界资源：必须互斥访问的资源。例如，需要独占使用的硬件资源，多个进程共享的变量、结构、队列、栈、文件等软件资源。②临界区：访问临界资源的、必须互斥地执行的程序段。即，当一个进程在某个临界段中执行时，其他进程不能进入相同临界资源的任何临界段。
操作系统实验3答案
实验三操作系统进程管理 一、实验目的 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系列操作系统常见进程列表(精华)
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)