操作系统实验
实验二进程管理
学号
姓名
班级
华侨大学电子工程系
实验目的
1、理解进程的概念,明确进程和程序的区别。
2、理解并发执行的实质。
3、掌握进程的创建、睡眠、撤销等进程控制方法。
实验内容与要求
基本要求:用C语言编写程序,模拟实现创建新的进程;查看运行进程;换出某个进程;杀死进程等功能。
实验报告内容
1、进程、进程控制块等的基本原理。
进程是现代操作系统中的一个最基本也是最重要的概念,掌握这个概念对于理解操作系统实质,分析、设计操作系统都有其非常重要的意义。为了强调进程的并发性和动态性,可以给进程作如下定义:进程是可并发执行的程序在一个数据集合上的运行过程,是系统进行资源分配和调度的一个独立单位。
进程又就绪、执行、阻塞三种基本状态,三者的变迁图如下:
由于多个程序并发执行,各程序需要轮流使用CPU,当某程序不在CPU上运行时,必须保留其被中断的程序的现场,包括:断点地址、程序状态字、通用寄存器的内容、堆栈内容、程序当前状态、程序的大小、运行时间等信息,以便程序再次获得CPU时,能够正确执行。为了保存这些内容,需要建立—个专用数据结构,我们称这个数据结构为进程控制块PCB (Process Control Block)。
进程控制块是进程存在的惟一标志,它跟踪程序执行的情况,表明了进程在当前时刻的状态以及与其它进程和资源的关系。当创建一个进程时,实际上就是为其建立一个进程控制块。
在通常的操作系统中,PCB应包含如下一些信息:
①进程标识信息。为了标识系统中的各个进程,每个进程必须有惟一的标识名或标
识数。
②位置信息。指出进程的程序和数据部分在内存或外存中的物理位置。
③状态信息。指出进程当前所处的状态,作为进程调度、分配CPU的依据。
④进程的优先级。一般根据进程的轻重缓急其它信息。
这里给出的只是一般操作系统中PCB所应具有的内容,不同操作系统的PCB结构是不同的,我们将在2.8节介绍Linux系统的PCB结构。
程度为进程指定一个优先级,优先级用优先数表示。
⑤进程现场保护区。当进程状态变化时(例如一个进程放弃使用CPU),它需要将当时的CPU现场保护到内存中,以便再次占用CPU时恢复正常运行,有的系统把要保护的CPU 现场放在进程的工作区中,而PCB中仅给出CPU现场保护区起始地址。
⑥资源清单。每个进程在运行时,除了需要内存外,还需要其它资源,如I/O设备、外存、数据区等。这一部分指出资源需求、分配和控制信息。
⑦队列指针或链接字。它用于将处于同一状态的进程链接成一个队列,在该单元中存放下一进程PCB首址。
⑧其它信息。
这里给出的只是一般操作系统中PCB所应具有的内容,不同操作系统的PCB结构是不同的,我们将在2.8节介绍Linux系统的PCB结构。
2、程序流程图。
3、程序及注释。
#include
#include
#include
struct jincheng_type{ // 定义表示进程信息的结构体
int pid; //进程ID
int youxian; //优先级
int daxiao; //大小
int zhuangtai; //进程的状态,这里用0表示没有建立或被杀死,1表示执行,2表示换出
int info; //内容
};
struct jincheng_type neicun[20]; //定义20个内存单位给进程使用
int shumu=0,guaqi=0,pid,flag=0; //定义正在执行进程数目,被挂起进程数目,进程ID,运行标志位
void create() //函数——创建一个新进程
{
if(shumu>=20) printf("\n内存已满,请先换出或杀死进程\n"); //判断内存空间是否已满
else{
for(int i=0;i<20;i++)
if(neicun[i].zhuangtai==0) break; //选出空着的内存单元给新进程使用
printf("\n请输入新进程pid\n"); //输入新进程ID存至选出的内存单元
scanf("%d",&(neicun[i].pid));
for(int j=0;j
if(neicun[i].pid==neicun[j].pid) //当输入的新进程与原有进程ID相同时,显示“该进程已存在”
{
printf("\n该进程已存在\n");
return;
}
printf("\n请输入新进程优先级\n"); //输入新进程的优先级、大小和内容
scanf("%d",&(neicun[i].youxian));
printf("\n请输入新进程大小\n");
scanf("%d",&(neicun[i].daxiao));
printf("\n请输入新进程内容\n");
scanf("%d",&(neicun[i].info));
neicun[i].zhuangtai=1; //将新进程的内存单元状态(zhuangtai)设成“1”,以表示存在且未被换出
shumu++; //正在运行的进程数目加一
}
}
void run() //函数——查看正在运行的进程
{
for(int i=0;i<20;i++)
{
if(neicun[i].zhuangtai==1) //将存在且未被挂起(即zhuangtai=1)的进程显示出来,若存在这样的程序,则将flag设成1
{
printf("\n pid=%d",neicun[i].pid);
printf("youxian=%d",neicun[i].youxian);
printf("daxiao=%d",neicun[i].daxiao);
printf("zhuangtai=%d",neicun[i].zhuangtai);
printf("info=%d",neicun[i].info);
flag=1;
}
}
if(!flag) printf("\n当前没有运行进程\n"); //若当前没有运行进程(即flag=0),则显示“当前没有运行进程”
}
void huanchu() //函数——换出进程
{
if(!shumu) //判断是否无进程存在
{
printf("\n当前没有进程存在\n");
return;
}
printf("\n 输入唤出进程ID值"); //输入需要换出的进程ID,
scanf("%d",&pid);
for(int i=0;i<20;i++)
{
if(pid==neicun[i].pid)
{
if(neicun[i].zhuangtai==1) //若该ID代表的进程正在运行,则将其挂起,即将zhuangyai置成2,并将guaqi加一
{
neicun[i].zhuangtai=2;
guaqi++;
printf("\n已经成功换出进程\n");
}
else if(neicun[i].zhuangtai==2) printf("\n要唤出的进程已被挂起\n"); //若该ID代表的进程已被挂起,即zhuangtai==2,则显示‘要唤出的进程已被挂起’
flag=1;
break;
}
}
if(!flag) printf("\n要唤出的进程不存在\n"); //若进程不存在,给出显示
}
void kill() //函数——杀死进程
{
if(!shumu) //判断是否无进程存在
{
printf("\n当前没有进程存在\n");
return;
}
printf("\n 输入杀死进程的ID值"); //读入要杀死的进程ID
scanf("%d",&pid);
for(int i=0;i<20;i++)
{
if(pid==neicun[i].pid)
{
if(neicun[i].zhuangtai==1) //若进程正在运行则再次询问是否要杀死,通过用户的反馈执行不同操作
{
printf("\n该进程正在运行,您确定要杀死吗?\n");
printf("\n请输入1:确定;0:不确定\n");
scanf("%d",&flag);
if(flag)
{
neicun[i].zhuangtai=0; //将zhuangtai置为0,表示进程被杀死,并将shumu自减一
shumu--;
printf("\n已经成功杀死进程\n");
}
else printf("\要杀死的进程正在运行\n");
}
else if(neicun[i].zhuangtai==2) //若该进程已经被挂起,则直接杀死
{
neicun[i].zhuangtai=0;
shumu--;
printf("\n已经成功杀死进程\n");
}
flag=1;
break;
}
}
if(flag==0) printf("\n要杀死的进程不存在\n"); //若进程不存在,给出显示
}
void huanxing() //函数——唤醒进程
{
if(!shumu) //判断是否无进程存在
{
printf("\n当前没有运行进程\n");
return;
}
if(!guaqi) //判断是否无进程被挂起
{
printf("\n当前没有挂起进程\n");
return;
}
printf("\n输入pid\n"); //输入需要唤醒进程ID
scanf("%d",&pid);
for(int i=0;i<20;i++)
{
if(pid==neicun[i].pid)
{
flag=false;
if(neicun[i].zhuangtai==2) //判断该进程是否被挂起,若没有则将其唤醒并将guaqi自减一
{
neicun[i].zhuangtai=1;
guaqi--;
printf("\n已经成功唤醒进程\n");
}
else if(neicun[i].zhuangtai==2) printf("\n要唤醒的进程已被挂起\n"); //若目标进程已被挂起,则显示‘要唤醒的进程已被挂起’
flag=1;
break;
}
}
if(!flag) printf("\n要唤醒的进程不存在\n"); //若要唤醒的进程不存在,给出显示
}
void viewall() //函数——查看内存状态
{
for(int i=0;i<20;i++) //显示所有20个内存单元的状态
{
printf("\n pid=%d",neicun[i].pid);
printf("youxian=%d",neicun[i].youxian);
printf("daxiao=%d",neicun[i].daxiao);
printf("zhuangtai=%d",neicun[i].zhuangtai);
printf("info=%d",neicun[i].info);
}
}
void main() //主函数
{
int n=1;
int num;
for(int i=0;i<20;i++) //先将内存zhuangtai位清零neicun[i].zhuangtai=0;
while(n)
{
printf("\n**********************************\n"); //用户操作界面
printf("\n**********************************\n");
printf("\n***********进程演示系统***********\n");
printf("\n 1.创建新的进程 2.查看运行进程\n");
printf("\n 3.唤出某个进程 4.杀死某个进程\n");
printf("\n 5.唤醒某个进程 6.查看内存状态\n");
printf("\n 7.退出进程\n");
printf("\n**********************************\n");
printf("\n请选择(1-7)\n");
scanf("%d",&num);
switch(num) //功能选择
{
case 1:create();break;
case 2:run();break;
case 3:huanchu();break;
case 4:kill();break;
case 5:huanxing();break;
case 6:viewall();break;
case 7:exit(0);
default:n=0;
}
flag=0;
}
}
4、程序运行演示与截图
(1)创建新进程,依次建立进程1、2、3,图中为建立进程2。
(2)查看运行的进程与查看内存状态
(2)换出进程。图中以换出进程3为例。
(4)此时再次查看运行的进程与查看内存状态,可以看到进程3已不在运行的进程中,内存状态中其zhuangtai标识等于2,表明进程3确实已被换出。
(5)唤醒进程。图为将进程3唤醒。
(6)此时再次查看运行的进程与查看内存状态,可以看到进程3重新出现在运行的进程中,且内存状态中其zhuangtai标识等于1,表明进程3已被成功唤醒。
(7)杀死进程。图中以杀死进程3为例,并附以杀死后运行的进程与内存状态图,内存状态中进程3的zhuangtai=0,表示进程3已被杀死。
5、实验结论
通过这次实验,我了解到进程控制块(PCB)在进程管理中的重要作用,它跟踪程序执行的情况,表明了进程在当前时刻的状态以及与其它进程和资源的关系。多个程序并发的执行需要依靠对PCB的控制来实现。
计算机操作系统进程调度实验研究报告
————————————————————————————————作者:————————————————————————————————日期:
操作系统实验题:设计一若干并发进程的进程调度程序 一、实验目的 无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 二、实验要求 用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解. 三、实验内容 进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。 每个进程有一个进程控制块(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
实验2过程管理实验报告学生号姓名班级电气工程系过程、过程控制块等基本原理过程的含义:过程是程序运行过程中对数据集的处理,以及由独立单元对系统资源的分配和调度。在不同的数据集上运行程序,甚至在同一数据集上运行多个程序,是一个不同的过程。(2)程序状态:一般来说,一个程序必须有三种基本状态:就绪、执行和阻塞。然而,在许多系统中,过程的状态变化可以更好地描述,并且增加了两种状态:新状态和终端状态。1)就绪状态,当一个进程被分配了除处理器(CPU)以外的所有必要资源时,只要获得了处理器,进程就可以立即执行。此时,进程状态称为就绪状态。在系统中,多个进程可以同时处于就绪状态。通常,这些就绪进程被安排在一个或多个队列中,这些队列称为就绪队列。2)一旦处于就绪状态的进程得到处理器,它就可以运行了。进程的状态称为执行状态。在单处理器系统中,只有一个进程在执行。在多处理器系统中,可能有多个进程在执行中。3)阻塞状态由于某些事件(如请求输入和输出、额外空间等),执行进程被挂起。这称为阻塞状态,也称为等待状态。通常,处于阻塞状态的进程被调度为-?这个队列称为阻塞队列。4)新状态当一个新进程刚刚建立并且还没有放入就绪队列中时,它被称为新状态。5)终止状态是
什么时候-?进程已正常或异常终止,操作系统已将其从系统队列中删除,但尚未取消。这就是所谓的终结状态。(3)过程控制块是过程实体的重要组成部分,是操作系统中最重要的记录数据。控制块PCB记录操作系统描述过程和控制过程操作所需的所有信息。通过PCB,一个不能独立运行的程序可以成为一个可以独立运行的基本单元,并且可以同时执行一个进程。换句话说,在进程的整个生命周期中,操作系统通过进程PCB管理和控制并发进程。过程控制块是系统用于过程控制的数据结构。系统根据进程的PCB来检测进程是否存在。因此,进程控制块是进程存在的唯一标志。当系统创建一个进程时,它需要为它创建一个PCB;当进程结束时,系统回收其PCB,进程结束。过程控制块的内容过程控制块主要包括以下四个方面的信息。过程标识信息过程标识用于对过程进行标识,通常有外部标识和内部标识。外部标识符由流程的创建者命名。通常是一串字母和数字。当用户访问进程时使用。外部标识符很容易记住。内部标识符是为了方便系统而设置的。操作系统为每个进程分配一个唯一的整数作为内部标识符。通常是进程的序列号。描述性信息(process scheduling message)描述性信息是与流程调度相关的一些有关流程状态的信息,包括以下几个方面。流程状态:表
实验二进程管理 (一)实验目的或实验原理 1.加深对进程概念的理解,明确进程和程序的区别。 2.进一步认识并发执行的实质。 3.分析进程竞争资源现象,学习解决进程互斥的方法。 4.了解Linux系统中进程通信的基本原理。 (二)实验内容 1.进程的创建。 2.进程的控制。 3.①编写一段程序,使其现实进程的软中断通信。 要求:使用系统调用fork()创建两个子进程,再用系统调用signal()让父进程捕捉键盘上来的中断信号(即按DEL键);当捕捉到中断信号后,父进程用系统调用Kill()向两个子进程发出信号,子进程捕捉到信号后分别输出下列信息后终止: Child Processll is Killed by Parent! Child Processl2 is Killed by Parent! 父进程等待两个子进程终止后,输出如下的信息后终止 Parent Process is Killed! ②在上面的程序中增加语句signal (SIGNAL, SIG-IGN) 和signal (SIGQUIT, SIG-IGN), 观察执行结果,并分析原因。 4.进程的管道通信。 编制一段程序,实现进程的管理通信。 使用系统调用pipe()建立一条管道线;两个子进程P1和P2分别向管道中写一句话: Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息,显示在屏幕上。 要求父进程先接收子进程P1发来的消息,然后再接收子进程P2发来的消息。 实验2 指导 [实验内容] 1.进程的创建 〈任务〉 编写一段程序,使用系统调用fork( )创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符;父进程显示字符“a”,子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果,并分析原因。 〈程序〉 #include<> main() { int p1,p2; if(p1=fork()) /*子进程创建成功*/ p utchar('b'); else { if(p2=fork()) /*子进程创建成功*/
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 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;
第二章操作系统进程(练习题答案)
————————————————————————————————作者:————————————————————————————————日期: 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。
操作系统进程管理实验 实验题目: (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
第二章进程管理 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、了解系统调用fork()、exec()、exit()和waitpid()的功能和实现过程。 2、编写一段程序,使用系统调用fork()创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示字符“a”;子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果,并分析原因。 3、编写一段程序,使用系统调用fork()来创建一个子进程,子进程通过系统调用exec()更换自己的执行代码,显示新的代码“new program.”后,调用exit()结束。而父进程则调用waitpid()等待子进程结束,并在子进程结束后显示子进程的标识符,然后正常结束。
实验指导 一、所涉及的系统调用 1、getpid 在2.4.4版内核中,getpid是第20号系统调用,其在Linux函数库中的原型是: getpid的作用很简单,就是返回当前进程的进程ID,请大家看以下的例子: 这个程序的定义里并没有包含头文件sys/types.h,这是因为我们在程序中没有用到pid_t类型,pid_t类型即为进程ID的类型。事实上,在i386架构上(就是我们一般
PC计算机的架构),pid_t类型是和int类型完全兼容的,我们可以用处理整形数的方法去处理pid_t类型的数据,比如,用"%d"把它打印出来。 编译并运行程序getpid_test.c: 再运行一遍: 正如我们所见,尽管是同一个应用程序,每一次运行的时候,所分配的进程标识符都不相同。 2、fork 在2.4.4版内核中,fork是第2号系统调用,其在Linux函数库中的原型是:
实验一进程管理 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
实验项目二进程管理 一、实验目的 1.理解进程的概念,掌握父、子进程创建的方法。 2.认识和了解并发执行的实质,掌握进程的并发及同步操作。 二、实验内容 1.编写一C语言程序,实现在程序运行时通过系统调用fork( ) 创建两个子进程,使父、子三进程并发执行,父亲进程执行 时屏幕显示“I am father ,”儿子进程执行时屏幕显示“I am son ”,女儿进程执行时屏幕显示“ I am daughter。” 2.多次连续反复运行这个程序,观察屏幕显示结果的顺序,直 至出现不一样的情况为止。记下这种情况,试简单分析其原 因。 3.修改程序,在父、子进程中分别使用wait() 、exit()等系统调用 “实现”其同步推进,并获取子进程的ID 号及结束状态值。 多次反复运行改进后的程序,观察并记录运行结果。 三、源程序及运行结果 源程序 1: #include
pid = fork(); if (pid == -1) { printf("failed"); exit(1); } else if (pid == 0) { a = "I am son"; } else { a = "I am father"; pid = fork(); if (pid == -1) { printf("failed"); exit(1); } else if (pid == 0) { a = "I am daughter"; } } for (num=3;num>0;num--) { puts(a); sleep(1); } exit(0); } 运行结果:
操作系统实验实验二进程管理 学号 1215108019 姓名克帆 学院信息学院 班级 12电子2
实验目的 1、理解进程的概念,明确进程和程序的区别。 2、理解并发执行的实质。 3、掌握进程的创建、睡眠、撤销等进程控制方法。 实验容与要求 基本要求:用C语言编写程序,模拟实现创建新的进程;查看运行进程;换出某个进程;杀死进程等功能。 实验报告容 1、进程、进程控制块等的基本原理。 进程是现代操作系统中的一个最基本也是最重要的概念,掌握这个概念对于理解操作系统实质,分析、设计操作系统都有其非常重要的意义。为了强调进程的并发性和动态性,可以给进程作如下定义:进程是可并发执行的程序在一个数据集合上的运行过程,是系统进行资源分配和调度的一个独立单位。 进程又就绪、执行、阻塞三种基本状态,三者的变迁图如下: 由于多个程序并发执行,各程序需要轮流使用CPU,当某程序不在CPU上运行时,必须保留其被中断的程序的现场,包括:断点地址、程序状态字、通用寄存器的容、堆栈容、程序当前状态、程序的大小、运行时间等信息,以便程序再次获得CPU时,能够正确执行。为了保存这些容,需要建立—个专用数据结构,我们称这个数据结构为进程控制块PCB (Process Control Block)。 进程控制块是进程存在的惟一标志,它跟踪程序执行的情况,表明了进程在当前时刻的状态以及与其它进程和资源的关系。当创建一个进程时,实际上就是为其建立一个进程控制块。 在通常的操作系统中,PCB应包含如下一些信息: ①进程标识信息。为了标识系统中的各个进程,每个进程必须有惟一的标识名或标 识数。 ②位置信息。指出进程的程序和数据部分在存或外存中的物理位置。 ③状态信息。指出进程当前所处的状态,作为进程调度、分配CPU的依据。 ④进程的优先级。一般根据进程的轻重缓急其它信息。 这里给出的只是一般操作系统中PCB所应具有的容,不同操作系统的PCB结构是不同的,我们将在2.8节介绍Linux系统的PCB结构。
实验2 进程管理 1、实验目的 (1)加深对进程概念的理解,明确进程和程序的区别。 (2)进一步认识并发执行的实质。 (3)分析进程竞争资源现象,学习解决进程互斥的方法。 (4)了解Linux系统中进程通信的基本原理。 2、实验预备内容 (1)阅读Linux的sched.h源文件,加深对进程管理概念的理解。 (2)阅读Linux的fork.c源文件,分析进程的创建过程。 3、实验内容 (1)进程的创建 编写一段源程序,使系统调用fork()创建两个子进程,当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果,并分析原因。(2)进程的控制 修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,在观察程序执行时屏幕出现的现象,并分析原因。 如果在程序中使用调用lockf()来给每一个子进程加锁,可以实现进程之间的互斥,观察并分析出现的现象。 (3)①编写一段程序,使其实现进程的软中断通信。 要求:使用系统调用fork()创建两个子进程,再用系统调用signal()让父进程捕捉键盘上来的中断信号(即按DEL键);当捕捉到中断信号后,父进程用系统调用Kill()向两个子进程发出信号,子进程捕捉到信号后分别输出下列信息后终止: Child Processll is Killed by Parent! Child Processl2 is Killed by Parent! 父进程等待两个子进程终止后,输出如下的信息后终止 Parent Process is Killed! ②在上面的程序中增加语句signal (SIGNAL, SIG-IGN) 和signal (SIGQUIT, SIG-IGN), 观察执行结果,并分析原因。
习题集 - 2 - 进程管理 1. 在优先级调度中,__________类进程可能被“饿死”,即长时间得不到调度。 A.短进程 B.长进程 C.低优先级进程 D.大内存进程 解: C。优先级调度算法(PRI)的基本思想是:内核为每个进程赋予一个优先级,进程按照优先级的大小顺序在就绪队列中排队,内核将CPU分配给就绪队列头部的第一个进程——优先级最大的进程。因此,进程的优先级越低,在就绪队列中的排队位置就越靠近队列尾,获得运行之前的等待时间就越长。低优先级的进程必须等待所有高优先级进程运行结束后才会被调度运行。如果不断有高优先级的进程加入就绪队列,那么低优先级进程就会一直等待下去。这就是所谓的“饿死”现象。 2. 在下面的系统调用中,__________不会导致进程阻塞。 A.读/写文件 B.获得进程PID C.申请内存 D.发送消息 解: B。当正在执行的进程需要使用某种资源或等待某个事件时,如果资源已被其他进程占用或事件尚未出现,该进程不能获得所需的资源而无法继续运行,于是,进程将被阻塞。进程在阻塞状态中等待资源被释放,或等待事件的发生。所以,进程在执行系统调用时,如果需要使用某种资源,就可能导致进程阻塞。“读/写文件”需要使用设备和文件缓冲区;“申请内存”需要分配内存资源;“发送消息”需要使用消息缓冲区。 3. 下面关于临界区的叙述中,正确的是__________ A.临界区可以允许规定数目的多个进程同时执行 B.临界区只包含一个程序段 C.临界区是必须互斥地执行的程序段 D.临界区的执行不能被中断 解: C。临界段(临界区)的概念包括两个部分:①临界资源:必须互斥访问的资源。例如,需要独占使用的硬件资源,多个进程共享的变量、结构、队列、栈、文件等软件资源。②临界区:访问临界资源的、必须互斥地执行的程序段。即,当一个进程在某个临界段中执行时,其他进程不能进入相同临界资源的任何临界段。
实验五进程管理命令 一、实验目的 (1)了解如何监视系统运行状态 (2)掌握查看、删除进程的正确方法 (3)掌握命令在后台运行的用法 (4)掌握进程手工、调度启动的方法 二、常用命令 who 查看当前在线用户 top 监视系统状态 ps 查看进程 kill 向进程发信号 bg 把进程变成后台运行 & 把进程变成后台运行 fg 把后台进程变成前台运行 jobs 显示处于后台的进程。 at 在指定的时刻执行指定的命令或命令序列 batch 在系统负载较低、资源较空闲时执行命令或命令序列以上命令的具体用法请参阅教材、课件和man手册 三、实验内容 1、用top命令察看当前系统的状态,并识别各进程的有关栏目。 2、用ps命令察看系统当前的进程,并把系统当前的进程保存到文件 process中。
3、用ps命令察看系统当前有没有init进程。 4、输入“cat <回车>” 按
操作系统实验 实验二进程管理 学号 姓名 班级 华侨大学电子工程系
实验目的 1、理解进程的概念,明确进程和程序的区别。 2、理解并发执行的实质。 3、掌握进程的创建、睡眠、撤销等进程控制方法。 实验内容与要求 基本要求:用C语言编写程序,模拟实现创建新的进程;查看运行进程;换出某个进程;杀死进程等功能。 实验报告内容 1、进程、进程控制块等的基本原理。 进程是现代操作系统中的一个最基本也是最重要的概念,掌握这个概念对于理解操作系统实质,分析、设计操作系统都有其非常重要的意义。为了强调进程的并发性和动态性,可以给进程作如下定义:进程是可并发执行的程序在一个数据集合上的运行过程,是系统进行资源分配和调度的一个独立单位。 进程又就绪、执行、阻塞三种基本状态,三者的变迁图如下: 由于多个程序并发执行,各程序需要轮流使用CPU,当某程序不在CPU上运行时,必须保留其被中断的程序的现场,包括:断点地址、程序状态字、通用寄存器的内容、堆栈内容、程序当前状态、程序的大小、运行时间等信息,以便程序再次获得CPU时,能够正确执行。为了保存这些内容,需要建立—个专用数据结构,我们称这个数据结构为进程控制块PCB (Process Control Block)。 进程控制块是进程存在的惟一标志,它跟踪程序执行的情况,表明了进程在当前时刻的状态以及与其它进程和资源的关系。当创建一个进程时,实际上就是为其建立一个进程控制块。 在通常的操作系统中,PCB应包含如下一些信息: ①进程标识信息。为了标识系统中的各个进程,每个进程必须有惟一的标识名或标 识数。 ②位置信息。指出进程的程序和数据部分在内存或外存中的物理位置。 ③状态信息。指出进程当前所处的状态,作为进程调度、分配CPU的依据。 ④进程的优先级。一般根据进程的轻重缓急其它信息。 这里给出的只是一般操作系统中PCB所应具有的内容,不同操作系统的PCB结构是不同的,我们将在2.8节介绍Linux系统的PCB结构。
计算机与信息工程学院实验报告 一、实验内容 1.练习在shell环境下编译执行程序 (注意:①在vi编辑器中编写名为sample.c的c语言源程序 ②用linux自带的编译器gcc编译程序,例如:gcc –o test sample.c ③编译后生成名为test.out的可执行文件; ④最后执行分析结果;命令为:./test) 注意:linux自带的编译程序gcc的语法是:gcc –o 目标程序名源程序名,例如:gcc –o sample1 sample1.c,然后利用命令:./sample 来执行。如果仅用“gcc 源程序名”,将会把任何名字的源程序都编译成名为a.out的目标程序,这样新编译的程序会覆盖原来的程序,所以最好给每个源程序都起个新目标程序名。 2.进程的创建 仿照例子自己编写一段程序,使用系统调用fork()创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示“a”,子进程分别显示字符“b”和“c”。观察记录屏幕上的显示结果,并分析原因。 3.分析程序 实验内容要在给出的例子程序基础上,根据要求进行修改,对执行结果进行分析。二、
实验步骤 1. 利用fork()创建一个小程序 (1)编写程序 #include
实验三操作系统进程管理 一、实验目的 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时出现
作业题: 1.有一个充分大的池子,两个人分别向池中扔球,甲扔红球,乙扔蓝球,一次扔一个,开始时池中有红、蓝球各一个,要求池中球满足条件: 红球数 1≤———≤ 2 蓝球数 用P、V操作描述两个进程。 Semaphore red =1; Semaphore blue =0; Void p1 ( ) { While(true) { Semwait (red ); 扔入一个红球; Semsignal(blue); } } Void p2( ) { While(true) { Semwait(blue); 扔入一个蓝球; Semsignal(red); Semsignal(red); } } Void main() {parbegin(p1(),p2());} 2.有三个进程,进程get从输入设备上不断读数据,并存入buffer1;进程copy不断将buffer1的内容复制到缓冲区buffer2,进程put则不断将buffer2的内容在打印机上输出。三个进程并发执行,协调工作。写出该三个进程并发执行的同步模型。 Semaphore empty1=empty2=1; Semaphore full1 =full2= 0; Void get( ) { While(true) {
Semwait(empty1); 将数据存入buffer1; Semsignal(full1); } } Void copy( ) { While(true) { Semwait(full1); 从buffer1里面读数据; Semsignal(empty1); Semwait(empty2); 把数据存入buffer2; Semsignal(full2); } } Void put( ) { While(true) { Semwait(full2); 从buffer2读数据;Semsignal(empty2); } } Void main( ) { Parbegin(get(),copy(),put()); }