实验二 进程管理
操作系统实验二:进程管理
操作系统实验二:进程管理操作系统实验二:进程管理篇一:操作系统实验报告实验一进程管理一、目的进程调度是处理机管理的核心内容。
本实验要求编写和调试一个简单的进程调度程序。
通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。
二、实验内容及要求1、设计进程控制块PCB的结构(PCB结构通常包括以下信息:进程名(进程ID)、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。
可根据实验的不同,PCB结构的内容可以作适当的增删)。
为了便于处理,程序中的某进程运行时间以时间片为单位计算。
各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
2、系统资源(r1…rw),共有w类,每类数目为r1…rw。
随机产生n进程Pi(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; //进程IDpublic 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为时间片大小(毫秒)//对进程进行初始化,建立就绪数组、阻塞数组。
实验二 进程管理
5.进程调度模拟编写程序完成单处理机系统中的进程调度,要求采用先来先服务算法、最短CPU运行期优先调度算法、优先级调度算法、多级反馈队列轮转算法。
实验具体包括:首先确定进程控制块的内容和进程控制块的组织方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所做工作进行测试。
1)实验提示与讲解这个实验主要需要考虑三个问题:如何组织进程、如何创建进程和如何实现处理器调度。
考虑如何组织进程,首先就要设定进程控制块的内容。
进程控制块PCB记录各个进程执行时的情况。
不同的操作系统,进程控制块记录的信息内容不一样。
操作系统功能越强,软件也越庞大,进程控制块记录的内容也就越多。
这里的实验只是用了必不可少的信息。
一般操作系统中,无论进程控制块中信息量多少,信息都可以大致分为以下四类:①标识信息每个进程都要有一个唯一的标识符,用来标识进程的存在和区别于其他进程。
这个标识符是必不可少的,可以用符号或编号实现,它必须是操作系统分配的。
在后面给出的参考程序中,采用编号方式,也就是为每个进程依次分配一个不相同的正整数。
②说明信息用于记录进程的基本情况,例如进程的状态、等待原因、进程程序存放的位置、进程数据存放位置等等。
实验中,因为进程没有数据和程序,仅使用进程控制块模拟进程,所以这部分内容仅包括进程状态。
③现场信息现场信息记录各个寄存器的内容。
当进程由于某种原因让出处理器时,需要将现场信息记录在进程控制块中,当进行进程调度时,从选中进程的进程控制块中读取现场信息进行现场恢复。
现场信息就是处理器的相关寄存器内容,包括通用寄存器、程序计数器和程序状态字等。
在实验中,可选取几个寄存器作为代表。
用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字。
④管理信息管理信息记录进程管理和调度的信息。
例如进程优先数、进程队列指针等。
实验中,仅包括队列指针。
因此,可将进程控制块结构定义如下:struct pcb{int name; //进程标识符int status; //进程状态int AX,BX,CX,DX; //进程现场信息,通用寄存器内容int PC; //进程现场信息,程序计数器内容int PSW; //进程现场信息,程序状态字内容int next; //下一个进程控制块的位置}确定进程控制块内容后,要考虑的就是如何将进程控制块组织在一起。
最新实验二-实验报告(进程管理)
最新实验二-实验报告(进程管理)实验目的:1. 理解操作系统中进程的概念及其特性。
2. 掌握进程管理的基本原理和方法。
3. 学习进程创建、撤销、阻塞和唤醒等操作。
4. 熟悉进程间的同步与通信机制。
实验环境:- 操作系统:Linux/Unix- 编程语言:C/C++- 开发工具:GCC编译器,GDB调试器实验内容:1. 创建进程:编写程序,使用系统调用fork()创建子进程,并观察父进程与子进程的行为差异。
2. 进程撤销:实现一个程序,通过系统调用exit()或abort()撤销进程,并观察其对进程组和会话的影响。
3. 进程阻塞与唤醒:设计并实现一个父进程和多个子进程的程序,其中子进程执行阻塞操作(如sleep()),父进程负责唤醒这些子进程。
4. 进程同步:利用信号量或管程等同步机制,实现两个并发进程的同步操作。
5. 进程通信:通过管道(PIPE)、消息队列、共享内存等IPC机制,实现进程间的信息交换。
实验步骤:1. 设计并编写创建进程的程序代码。
2. 在Linux环境下使用GCC编译程序,并记录编译过程。
3. 运行程序,使用GDB等工具调试程序,并观察fork()的执行效果。
4. 实现进程撤销的程序,并记录exit()和abort()的不同行为。
5. 编写进程阻塞与唤醒的程序,并通过实验观察不同进程状态的变化。
6. 完成进程同步的代码实现,并测试死锁及其解决方法。
7. 编写并测试进程通信的程序,确保信息能够正确传递。
实验结果:- 展示创建进程前后的系统状态变化,包括进程表和内存分配情况。
- 记录进程撤销后,父进程收集子进程状态的输出。
- 展示进程阻塞与唤醒的输出结果,验证进程状态转换的正确性。
- 展示进程同步的实验结果,包括死锁的产生与解决。
- 展示进程通信的测试结果,验证信息传递的准确性。
实验分析:- 分析进程创建和撤销的系统资源变化。
- 讨论进程阻塞与唤醒机制的效率和应用场景。
- 探讨进程同步与通信的复杂性及其在多线程编程中的重要性。
实验二 进程管理(实验报告格式)
实验二:进程管理一、实验目的(1)理解进程的概念,掌握父、子进程创建的方法。
(2)认识和了解并发执行的实质,掌握进程的并发及同步操作。
二、实验环境微型计算机,Ubuntu Linux10.04 ,gedit,gcc三、实验内容1.编写一C语言程序,实现在程序运行时通过系统调用fork( )创建两个子进程,使父、子三进程并发执行,父亲进程执行时屏幕显示“I am father”,儿子进程执行时屏幕显示“I am son”,女儿进程执行时屏幕显示“I am daughter”。
2.多次连续反复运行这个程序,观察屏幕显示结果的顺序,直至出现不一样的情况为止。
记下这种情况,试简单分析其原因。
3.修改程序,在父、子进程中分别使用wait()、exit()等系统调用“实现”其同步推进,并获取子进程的ID号及结束状态值。
多次反复运行改进后的程序,观察并记录运行结果。
四、实验结果一般程序结果是:I am father!I am sonI am daughter!但执行多遍之后有时会变成这样的:I am father!I am daughter!I am son五、源代码、#include<stdlib.h>#include<unistd.h>#include<stdio.h>#include<sys/types.h>#include<sys/wait.h>int main(){//pid_t pid1=fork();//pid_t pid2=fork();pid_t pid;int i;pid=fork();if(pid==-1){printf("faild to fock!\n");exit(1);}elseif(pid==0){//sleep(1);printf("I am son\n");}else{//sleep(1);printf("I am father!\n");pid=fork();if(pid==-1){printf("faild to fock!\n");exit(1);}elseif(pid==0){//sleep(1);printf("I am daughter!\n");}//nice(1);}return 0;}世上没有一件工作不辛苦,没有一处人事不复杂。
计算机操作系统实验二Windows任务管理器的进程管理
计算机操作系统实验二Windows任务管理器的进程管理实验二 Windows任务管理器的进程管理一实验目的1)在Windows 任务管理器中对程序进程进行响应的管理操作;2)熟悉操作系统进程管理的概念;3)学习观察操作系统运行的动态性能。
二实验环境需要准备一台运行Windows XP操作系统的计算机。
三背景知识Windows XP的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息,也显示了最常用的度量进程性能的单位。
使用任务管理器,可以打开监视计算机性能的关键指示器,快速查看正在运行的程序的状态,或者终止已停止响应的程序。
也可以使用多个参数评估正在运行的进程的活动,以及查看CPU 和内存使用情况的图形和数据。
四实验内容与步骤启动并进入Windows环境,单击Ctrl + Alt + Del键,或者右键单击任务栏,在快捷菜单中单击“任务管理器”命令,打开“任务管理器”窗口。
当前机器中由你打开,正在运行的应用程序有:1) 实验二Windows 任务管理器的进程管理2) 常州大学—Windows Internet Explore3) 实验一Windows XP 系统管理4)可移动磁盘(H:)Windows“任务管理器”的窗口由_5_个选项卡组成,分别是:1) 应用程序2) 进程3) 性能4)联网当前“进程”选项卡显示的栏目分别是(可移动窗口下方的游标/箭头,或使窗口最大化进行观察) :1) 映像名称2) 用户名3) CPU4) 内存使用1. 使用任务管理器终止进程步骤1:单击“进程”选项卡,一共显示了__24_个进程。
请试着区分一下,其中:系统(SYSTEM) 进程有_14_个,填入表2-1中。
表2-1 实验记录映像名称用户名作用内存使用svchost.exe SYSTEM 用于执行dll文件 4988Kspoolsv.exe SYSTEM 管理所有本地和网络打 5544K印队列及控制所有打印工作lsass.exe SYSTEM 本地安全授权服务1460K services.exe SYSTEM 远程控制木马病毒3816Kwinlogon.exe SYSTEM 管理用户登录和退出5244Kcarss.exe SYSTEM 负责控制windows 12552K smss.exe SYSTEM 系统关键进程 500K CDAC11BA.exe SYSTEM 反复制保护软件1440K server.exe SYSTEM 用于Novell服务监听1196K MATLAB.exe SYSTEM 一种科学计算工程软件46576K MDM.exe SYSTEM 进行本地和远程调试 3532K service.exe SYSTEM 管理启动停止服务 3366K Inetinfo.exe SYSTEM 用于Debug调试除错 10236K system SYSTEM 系统进程 312K服务(SERVICE) 进程有_3_个,填入表2-2中。
进程管理实验二
#include<stdio.h>main(){int p,x;p=fork();if(p>0){x=fork();if(x>0)printf("father\n");elseprintf("child2");}elseprintf("child1");}实验步骤及输出结果:[test@localhost 桌面]$ gcc -o 1 1.c[test@localhost 桌面]$ ./1father[test@localhost 桌面]$ child2child12、运行以下程序,分析程序执行过程中产生的进程情况。
#include <stdio.h>main(){int p,x;p=fork();if (p>0)fork();else{fork();fork();}sleep(15);}实验步骤:编译连接 gcc –o forktree forktree.c后台运行 ./forktree &使用 pstree –h 查看进程树实验步骤及输出结果:[test@localhost 桌面]$ gcc -o forktree forktree.c[test@localhost 桌面]$ ./forktree &[1] 3952[test@localhost 桌面]$ pstree -hinit─┬─NetworkManager─┬─dhclient│ └─{NetworkManager}├─abrtd├─acpid├─atd├─auditd───{auditd}├─automount───4*[{automount}]├─avahi-daemon───avahi-daemon├─bonobo-activati───{bonobo-activat}├─clock-applet├─console-kit-dae───63*[{console-kit-da}]├─crond├─2*[dbus-daemon───{dbus-daemon}]├─2*[dbus-launch]├─devkit-power-da├─gconf-im-settin├─gconfd-2├─gdm-binary───gdm-simple-slav─┬─Xorg│└─gdm-session-wor───gnome-session─┬─abrt-ap+│ ├─bluetoo+│ ├─gdu-not+│ ├─gnome-p+│ ├─gnome-p+│ ├─gnome-v+│ ├─gpk-upd+│├─metacit+│ ├─nautilus│ ├─polkit-+│├─restore+│ ├─rhsm-co+│ └─{gnome-+├─gdm-user-switch├─gedit├─gnome-keyring-d───2*[{gnome-keyring-}]├─gnome-screensav├─gnome-settings-───{gnome-settings}├─gnome-terminal─┬─bash───pstree│ ├─gnome-pty-helpe│ └─{gnome-terminal}├─gnote├─gvfs-afc-vol ume───{gvfs-afc-volum}├─gvfs-gdu-volume├─gvfs-gphoto2-vo├─gvfsd├─gvfsd-burn├─gvfsd-computer├─gvfsd-metadata├─gvfsd-trash├─hald───hald-runner─┬─hald-addon-acpi│ └─hald-addon-inpu├─ibus-x11├─im-settings-dae───ibus-daemon─┬─ibus-engine-pin│ ├─ibus-gconf│ ├─python│ └─{ibus-daemon}├─loop├─master─┬─pickup│└─qmgr├─5*[mingetty]├─modem-manager├─notification-ar├─notification-da├─polkitd├─pulseaudio─┬─gconf-helper│ └─2*[{pulseaudio}]├─rhsmcertd├─rpc.idmapd├─rpc.mountd├─rpc.rquot ad├─rpc.statd├─rpcbind├─rsyslogd───2*[{rsyslogd}]├─rtkit-daemon───2*[{rtkit-daemon}]├─seahorse-daemon├─sshd├─trashapplet├─udevd───2*[udevd]├─udisks-daemon───udisks-daemon├─wnck-applet├─wpa_s upplicant└─xinetd[1]+ Done ./forktree3、运行程序,分析运行结果。
操作系统实验报告二 进程管理 fork()
闽南师范大学实验报告
实 验 内 容 与 具 体 步 骤
第3页
闽南师范大学实验报告 通过此次实验对进程运行过程有了初步的了解,对用 fork()函数从已存在的进程创建一个新的 进程,会用 getpid()函数取得进程识别码。
实 验 心 得
注:如果填写内容超出表格,自行添加附页。ຫໍສະໝຸດ 第4页闽南师范大学
实验报告
班级
学号 姓名 成绩
同组人
实验日期
课程名称:操作系统
实验题目:进程管理
1.对理论课中学习的进程、程序等的概念作进一步的理解,明确进程和程序的区别; 2. 加深理解进程并发执行的概念,认识多进程的并发执行的实质;
实 验 目 的 与 要 求
PC 兼容机。Window xp 以上操作系统
} else if (pid == 0) { printf("child1 pid is %d\n",getpid()); for(i=0;i<26;i++) {
sleep(1); printf("%c\n",'A'+i); } } else { pid1=fork(); if(pid1==0){ printf("child2 pid is%d\n",getpid()); for(i=0;i<26;i++) { sleep(1); printf("%c\n",'a'+i); } } else if(pid1>0){ printf("parent pid is%d\n",getppid()); for(i=1;i<=26;i++) { sleep(1); printf("%d\n",i); } } } 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族调用可以执行给定程序。
实验二 进程管理(linux)
实验二进程管理(Linux)一、实验类型本实验为设计性实验。
二、实验目的与任务1)加深对进程概念的理解,明确进程和程序的区别。
2)进一步认识并发执行的实质三、预习要求1)进程的概念2)进程控制的概念及内容3)进程的并发执行4)熟悉互斥的概念5)用到的Linux函数有:fork(),lockf()等。
四、实验基本原理使用fork()系统调用来创建一个子进程,父进程和子进程并发执行,交替输出结果。
使用lockf()系统调用对临界区进行加锁操作,实现对共享资源的互斥使用。
五、实验仪器与设备(或工具软件)实验设备:计算机一台,软件环境要求: Linux操作系统和gcc编译器。
六、实验内容1)进程的创建编写一段程序,使用系统调用fork( ) 创建两个子程序。
当此程序运行时,在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。
运行程序10次,观察记录屏幕上的显示结果,并分析原因。
2)进程的控制修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,再观察程序执行时屏幕上出现的现象,并分析原因。
如果在程序中使用系统调用lockf()来给每一个进程加锁,可以实现进程间的互斥,观察并分析出现的现象。
(1)进程的创建参考程序如下:#include<stdio.h>main(){int p1,p2;while((p1=fork())==-1); //p父进程p1子进程1if(p1!=0){while(((p2=fork())==-1); //p父进程p2子进程2if(p2==0) putchar('b');else putchar('c');}else putchar('a');}运行结果:略cab bca bac分析:原因:Fork()函数有三个返回值:1.-1 执行不成功2.0 表示当前正在执行子进程3.其他数值表示当前正在执行父进程,值是子进程的进程标识符PID4.获取当前进程的标识符getpid()5.获取当前进程的父进程的标识符getppid()(2)进程的控制参考程序如下#include<stdio.h>main(){int p1,p2,i;while ((p1=fork())==-1); // 父进程p,子进程p1if(p1==0){for(i=0;i<500;i++)printf("child_p1_ %d\n",i);}else{while((p2=fork())==-1);//父进程p,子进程p2if(p2==0)for(i=0;i<500;i++)printf("chind_p2_ %d\n",i);else for(i=0;i<500;i++)printf("father_p_%d\n",i);}}运行结果:略分析:由于函数printf()输出和字符串之间不会被中断,因此字符串内部的字符顺序输出不变。
进程管理实验报告分析(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. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。
操作系统实验2进程管理报告
实验一进程管理一、实验目的:1.加深对进程概念的理解,明确进程和程序的区别;2.进一步认识并发执行的实质;3.分析进程争用资源的现象,学习解决进程互斥的方法;4.了解Linux系统中进程通信的基本原理;二、实验预备容:1.阅读Linux的sched.h源码文件,加深对进程管理概念的理解;2.阅读Linux的fork()源码文件,分析进程的创建过程;三、实验环境说明:1.此实验采用的是Win7(32bit)下虚拟机VMware-workstation-10.0.4build-2249910;2.ubuntu 版本3.19.0;3.直接编写c文件在终端用命令行执行;4.虚拟机分配8G存中的1024M;5.虚拟机名称knLinux;6.ubuntu用户名kn;四、实验容:1.进程的创建:a)题目要求:编写一段程序,使用系统调用fork() 创建两个子进程。
当此程序运行时,在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”,子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果,并分析原因。
b)程序设计说明:一个父进程,两个子进程,分别输出显示a,b,c。
c)源代码:d)运行结果:e)分析:由输出结果可知,运行结果不唯一,可以是abc,acb,bca等多种情况。
因为在程序中,并没有三个进程之间的同步措施,所以父进程和子进程的输出顺序是随机的。
在试验次数足够大的情况下,6中顺序都有可能出现:abc, acb, bac, bca, cab, cba。
2.进程的控制:a)修改已经编写的程序,将每个进程输出一个字符改为每个进程输出一句话,再观察程序执行时屏幕上出现的现象,并分析原因。
i.程序设计说明:将第一个程序中输出字符的语句改为输出parent process和childprocess1&2的语句。
ii.源代码:iii.运行结果:iv.分析:发现在结果中,运行结果同第一个程序,但是在一个进程输出语句的中途不会被打断,语句都是完整的。
电大操作系统实验2:进程管理实验
电大操作系统实验2:进程管理实验
实验目的:
1.加深对进程概念的理解,特别是进程的动态性和并发性。
2.了解进程的创建和终止。
3.学会查看进程的状态信息。
4.学会使用进程管理命令。
实验要求:
1.理解有关进程的概念,能够使用ps命令列出系统中进
程的有关信息并进行分析。
2.理解进程的创建和族系关系。
3.能够使用&,jobs,bg,at等命令控制进程的运行。
实验内容:
1.使用ps命令查看系统中运行进程的信息。
实验环境:
实验步骤和结果:
1.输入ps命令,可以报告系统当前的进程状态。
2.输入ps-e命令,可以显示系统中运行的所有进程,包括系统进程和用户进程。
3.输入ps-f命令,可以得到进程的详细信息。
进程控制:
1.后台进程
1) $grep "注册用户名" /etc/passwd。
/tmp/abc &
2.作业控制
1) 进程休眠60秒Sleep 60 &
2) 进程休眠30秒Sleep 30 &
3) 查看进程状态Jobs
4) 将睡眠30秒的sleep命令放在前台执行fg%2
3.发送中断信号
1) 后台运行sleep命令$sleep 120 &
2) 查看sleep进程的状态$ps-p pid
3) 终止sleep命令$kill -9 pid。
操作系统实验二 进程管理
操作系统实验实验二进程管理学号姓名班级华侨大学电子工程系实验目的1、理解进程的概念,明确进程和程序的区别。
2、理解并发执行的实质。
3、掌握进程的创建、睡眠、撤销等进程控制方法。
实验内容与要求基本要求:用C语言编写程序,模拟实现创建新的进程;查看运行进程;换出某个进程;杀死进程等功能。
实验报告内容1、进程、进程控制块等的基本原理。
进程是现代操作系统中的一个最基本也是最重要的概念,掌握这个概念对于理解操作系统实质,分析、设计操作系统都有其非常重要的意义。
为了强调进程的并发性和动态性,可以给进程作如下定义:进程是可并发执行的程序在一个数据集合上的运行过程,是系统进行资源分配和调度的一个独立单位。
进程又就绪、执行、阻塞三种基本状态,三者的变迁图如下:由于多个程序并发执行,各程序需要轮流使用CPU,当某程序不在CPU上运行时,必须保留其被中断的程序的现场,包括:断点地址、程序状态字、通用寄存器的内容、堆栈内容、程序当前状态、程序的大小、运行时间等信息,以便程序再次获得CPU时,能够正确执行。
为了保存这些内容,需要建立—个专用数据结构,我们称这个数据结构为进程控制块PCB (Process Control Block)。
进程控制块是进程存在的惟一标志,它跟踪程序执行的情况,表明了进程在当前时刻的状态以及与其它进程和资源的关系。
当创建一个进程时,实际上就是为其建立一个进程控制块。
在通常的操作系统中,PCB应包含如下一些信息:①进程标识信息。
为了标识系统中的各个进程,每个进程必须有惟一的标识名或标识数。
②位置信息。
指出进程的程序和数据部分在内存或外存中的物理位置。
③状态信息。
指出进程当前所处的状态,作为进程调度、分配CPU的依据。
④进程的优先级。
一般根据进程的轻重缓急其它信息。
这里给出的只是一般操作系统中PCB所应具有的内容,不同操作系统的PCB结构是不同的,我们将在2.8节介绍Linux系统的PCB结构。
程度为进程指定一个优先级,优先级用优先数表示。
进程管理操作系统linux实验
实验进程管理(一)进程的创建实验实验目的1、掌握进程的概念,明确进程的含义2、认识并了解并发执行的实质实验内容1、编写一段程序,使用系统调用fork()创建两个子进程。
当此程序运行时,在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示'a',子进程分别显示字符'b'和字符'c'。
试观察记录屏幕上的显示结果,并分析原因。
2、修改上述程序,每一个进程循环显示一句话。
子进程显示'daughter…'及'son ……',父进程显示'parent ……',观察结果,分析原因。
实验准备(1)阅读LINUX的fork.c源码文件(见附录二),分析进程的创建过程。
(2)阅读LINUX的sched.c源码文件(见附录三),加深对进程管理概念的认识。
实验指导一、进程UNIX 中,进程既是一个独立拥有资源的基本单位,又是一个独立调度的基本单位。
一个进程实体由若干个区(段)组成,包括程序区、数据区、栈区、共享存储区等。
每个区又分为若干页,每个进程配置有唯一的进程控制块PCB,用于控制和管理进程。
PCB 的数据结构如下:1、进程表项(Process Table Entry)。
包括一些最常用的核心数据:进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB 的指针P_Link、指向U 区进程正文、数据及栈在内存区域的指针。
2、U 区(U Area)。
用于存放进程表项的一些扩充信息。
每一个进程都有一个私用的U区,其中含有:进程表项指针、真正用户标识符u-ruid(read user ID)、有效用户标识符u-euid(effective user ID)、用户文件描述符表、计时器、内部I/O参数、限制字段、差错字段、返回值、信号处理数组。
操作系统实验之进程管理实验报告
本次操作系统实验是模拟进程管理过程,解决哲学家的就餐问题。个人本 次实验还比较顺利,使用了比较熟悉的 c++语言进行算法的编写,比较巧妙的 定义了两个类来定义哲学家和筷子对象的属性以及相应的动作,方便在各种就 餐过程中对筷子的资源进行申请和释放,以及哲学家实现相应的动作。另一个 觉得比较好的地方是解决了死锁问题,通过判断当前哲学家是否可以同时拿起 左右筷子来避免死锁。
①至多只允许四个哲学家同时进餐,以保证至少有一个哲学家可以进餐,
最终总会释放出他所用过的两只筷子,从而可使更多的哲学家进餐;
②仅当左右两只筷子均可用时,才允许哲学家拿起筷子就餐;
③规定奇数号哲学家先拿起右边筷子,然后再去拿左边筷子,而偶数号哲
学家则相反。
本实验中采取方法 2.
三、数据结构及功能设计
}; bool b[5]; int i, j; srand(time(0)); j = rand() % 5; for (i = j; i < j + 5; i++) {
b[i % 5] = philosopher[i % 5].eat(); cout << endl << "********************************************************" << endl; } for (i = j; i < j + 5; i++) { if (b[i % 5]) {
五、测试用例及运行结果、分析
测试结果截图:
分析:产生了一个随机数 0,并依次加 1 对每个哲学家进行分析。分析时首先看 左筷子是否可用,然后看右筷子,若有一个不可用则放下手中的另一只筷子,并 说明 need waiting。然后再下一时间段对每个哲学家再次分析,直到每个哲学 家都吃上饭,程序结束。 通过实验结果可得,程序正确运行,且解决了死锁问题。
实验二 Windows任务管理器的进程管理
实验二 Windows任务管理器的进程管理一实验目的1)在Windows 任务管理器中对程序进程进行响应的管理操作;2)熟悉操作系统进程管理的概念;3)学习观察操作系统运行的动态性能。
二实验环境需要准备一台运行Windows XP操作系统的计算机。
三背景知识Windows XP的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息,也显示了最常用的度量进程性能的单位。
使用任务管理器,可以打开监视计算机性能的关键指示器,快速查看正在运行的程序的状态,或者终止已停止响应的程序。
也可以使用多个参数评估正在运行的进程的活动,以及查看CPU 和内存使用情况的图形和数据。
四实验内容与步骤启动并进入Windows环境,单击Ctrl + Alt + Del键,或者右键单击任务栏,在快捷菜单中单击“任务管理器”命令,打开“任务管理器”窗口。
当前机器中由你打开,正在运行的应用程序有:1) 实验二Windows任务管理器的进程管理Windows“任务管理器”的窗口由5个选项卡组成,分别是:1) 应用程序2) 进程3) 性能4)联网5)用户当前“进程”选项卡显示的栏目分别是(可移动窗口下方的游标/箭头,或使窗口最大化进行观察) :1)映像名称2)用户名3)CPU4)内存使用步骤1:单击“进程”选项卡,一共显示了36个进程。
请试着区分一下,其中:系统(SYSTEM) 进程有19个,填入表2-1中。
表2-1 实验记录服务(SERVICE) 进程有1个,填入表2-2中。
用户进程有16个,填入表2-3中。
步骤2:单击要终止的进程,然后单击“结束进程”按钮。
终止进程,将结束它直接或间接创建的所有子进程。
例如,如果终止了电子邮件程序(如Outlook 98) 的进程树,那么同时也终止了相关的进程,如MAPI后台处理程序mapisp32.exe。
请将终止某进程后的操作结果与原记录数据对比,发生了什么:原窗口将被关闭,与原窗口相关的程序都将结束执行。
实验二-实验报告(进程管理)
实验二模拟实现进程管理组长:李和林软件1402一、实验目的1.理解进程的概念,明确进程和程序的区别。
2.理解并发执行的实质。
3.掌握进程的创建,睡眠,撤销等进程控制方法。
二、实验内容用C语言,JAVA语言,C++语言编写程序,模拟实现创建新的进程;查看运行进程,换出某个进程;杀死运行进程。
三、实验准备1.进程的定义进程是程序在一个数据集合上的运行过程,是系统资源分配和调度的一个独立单位。
一个程序在不同的数据集合上运行,乃至一个程序在同样数据集合上的多次运行都是不同的进程。
2.进程的状态通常情况下,一个进程必须具有就绪,执行和阻塞三种基本情况。
1)就绪状态当进程已分配到除处理器外的所有必要资源后,只要再获得处理器就可以立即执行,这时进程的状态就为就绪状态。
在一个系统里,可以有多个进程同时处于就绪状态,通常把这些就绪进程排成一个或多个队列,称为就绪队列。
2)执行状态处于就绪状态的进程一旦获得处理器,就可以运行,进程状态也就处于执行状态,在单处理器系统中,只能有一个进程处于执行状态,在多处理器系统中,则可能有多个进程处于执行状态3)阻塞状态正在执行的进程因为发生某些事件而暂停运行,这种受阻暂停的状态称为阻塞状态,也可称为等待状态。
通常将处于阻塞状态的进程拍成一个队列,称为阻塞队列,在有些系统中,也会按阻塞原因的不同将阻塞状态的进程排成多个队列。
3.进程状态之间的转换4.进程控制块1)进程控制块的作用进程控制块是进程实体的重要组成部分,主要包含下述四个方面的信息:a)进程标示信息b)说明信息c)现场信息d)管理信息5.进程控制块的组织方式1)链接方式2)索引方式6.进程控制原语1)创建原语2)撤销原语3)阻塞原语4)唤醒原语7.程序代码#include<stdio.h>#include<iostream>using namespace std;void clrscr();void create();void run( );void exchange( );//唤出void kill( );void wakeUp( );//唤醒struct process_type{int pid;int priority;//优先次序int size;int state;//状态char info[10];};struct process_type internalMemory[20];int amount=0,hangUp=0,pid,flag=0;//数目,挂起void main( ){int n;int a;n=1;clrscr( );while(n==1){cout<<"\n********************************************";cout<<"\n* 进程演示系统 *";cout<<"\n********************************************";cout<<"\n 1.创建新的进程 2.查看运行进程 ";cout<<"\n 3.换出某个进程 4.杀死运行进程 ";cout<<"\n 5.唤醒某个进程¨ 6.退出系统 ";cout<<"\n*********************************************"<<endl;cout<<"请选择 ";cin>>a;switch(a){case 1:create( );break;case 2:run( );break;case 3:exchange();//换出break;case 4:kill();break;case 5:wakeUp();break;case 6:exit(0);default:n=0;}}}void create(){ //创建进程int i=0;if (amount>=20){cout<<" 内存已满,请先结束或换出进程";}else{for (i=0;i<20;i++){if (internalMemory[i].state==0){break;}}cout<<"请输入新进程的pid: "<<endl;cin>>internalMemory[ i ].pid;cout<<"请输入新进程的优先级: "<<endl;cin>>internalMemory[amount].priority;cout<<"请输入新进程的大小: "<<endl;cin>>internalMemory[amount].size;cout<<"请输入新进程的内容: "<<endl;cin>>internalMemory[amount].info;internalMemory[i].state=1;amount++;}}void clrscr()//清除内存空间{for (int i=0;i<19;i++){internalMemory[i].pid=0;internalMemory[i].priority=0;internalMemory[i].size=0;internalMemory[i].state=0;}amount=0;}void run(){for (int i=0;i<20;i++){if (internalMemory[i].state==1){cout<<"当前内存中的进程:\n"<<endl;cout<<"当前运行的进程: ";cout<<internalMemory[i].pid<<endl;cout<<"当前运行进程的优先级: ";cout<<internalMemory[i].priority<<endl;cout<<"当前运行进程占用的空间大小: ";cout<<internalMemory[i].size;}}}void exchange( ){//唤出优先级最小的进程if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"\n输入换出进程的ID值: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=2;hangUp++;cout<<"\n已经成功换出进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换出的进程不存在";}else{cout<<"\n要换出的进程已被挂起\n";}flag=1;break;}}if (flag==0){cout<<"\n要换出的进程不存在";}}void kill( ){if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"请输入要杀死的进程: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=0;amount--;cout<<"此进程被杀死"<<pid;}else if (internalMemory[i].state==0){cout<<"\n要杀死的进程不存在\n";}else{cout<<"\n要杀死的进程已被挂起\n";}flag=1;break;}}if (!flag){cout<<"\n要杀死的进程不存在\n";}}void wakeUp(){if (!amount){cout<<"当前没有运行进程"<<endl;return;}if (!hangUp){cout<<"当前没有挂起进程";return;}cout<<"请输入pid: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){flag=0;if (internalMemory[i].state==2){internalMemory[i].state=1;hangUp--;cout<<"已经成功唤醒进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换醒的进程不存在\n";}else{cout<<"\n要唤醒的进程已被挂起\n";}break;}}if (flag){cout<<"\n要唤醒的进程已被挂起\n"<<endl;}}8.实现的结果。
操作系统 实验2进程控制管理 实验报告
{
while((p2=fork( ))= = -1); /*创建子进程p2*/
if(p2= =0)
for(i=0;i<10;i++)
printf("son %d\n",i);
else
for(i=0;i<10;i++)
printf("parent %d\n",i);
}
}
5.退出后,用同样方法查看此文件的代码内容。
2)修改上述程序,每一个进程循环显示一句话。子进程显示'daughter…'及'son……',父进程显示'parent……',观察结果,分析原因。
实验用到的软件(:)
虚拟机VMWare/Virtual Box
fedora15
实验内容及关键步骤(代码)Q3(15分)
1.按照上一次实验的步骤,进入后需要切换到管理员,输入“su root”,输入密码之后,可以输入“ls”查看目录下的文件。附加:为了熟悉上一节实验课内容,我先创建了一个myleb2的文件夹,然后再在这个文件夹里创建一个子文件夹love,再在里面编译。
6.查看无问题后,输入“gcc –o test2 test2.c”,修改运行文件名,然后查看该文件夹下的所有文件,能看到“test2”运行文件。
7.运行“test2”文件,输入“./test2”,可查看运行结果为“daughter 0,daughter 1,daughter 2,daughter 3….. daughter 9”。
3.首先是读入文件内容,再次是看文件有没有指定程序运行,如果有则运行,如果没有则输出出错的信息。
实验中的问题及解决办法:
(完整word版)实验二进程管理
实验二进程管理(一)实验目的或实验原理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〈stdio。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二进程管理(一)实验目的或实验原理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<stdio.h>main(){int p1,p2;if(p1=fork()) /*子进程创建成功*/putchar('b');else{if(p2=fork()) /*子进程创建成功*/putchar('c');else putchar('a'); /*父进程执行*/}}<运行结果>bca(有时会出现abc的任意的排列)分析:从进程执行并发来看,输出abc的排列都是有可能的。
原因:fork()创建进程所需的时间虽然可能多于输出一个字符的时间,但各个进程的时间片的获得却不是一定是顺序的,所以输出abc的排列都是有可能的。
2.进程的控制<任务>修改已编写好的程序,将每个程序的输出由单个字符改为一句话,再观察程序执行时屏幕上出现的现象,并分析其原因。
如果在程序中使用系统调用lockf()来给每个程序加锁,可以实现进程之间的互斥,观察并分析出现的现象。
〈程序1〉#include<stdio.h>main(){int p1,p2,i;if(p1=fork()){for(i=0;i<500;i++)printf("parent%d\n",i);wait(0); /* 保证在子进程终止前,父进程不会终止*/exit(0);}else{if(p2=fork()){for(i=0;i<500;i++)printf("son %d\n",i);wait(0); /* 保证在子进程终止前,父进程不会终止*/exit(0); /*向父进程信号0且该进程退出*/}else{for(i=0;i<500;i++)printf(“grandchild %d\n",i);exit(0);}}}〈运行结果〉parent….son…grandchild…grandchild…或grandchild…son…grandchild…son…parent分析:由于函数printf()输出的字符串之间不会被中断,因此,每个字符串内部的字符顺序输出时不变。
但是 , 由于进程并发执行时的调度顺序和父子进程的抢占处理机问题,输出字符串的顺序和先后随着执行的不同而发生变化。
这与打印单字符的结果相同。
〈程序2〉#include<stdio.h>#include<stdio.h>main(){int p1,p2,i;if(p1=fork()){lockf(1,1,0);for(i=0;i<500;i++)printf("parent %d\n",i);lockf(1,0,0);wait(0); /* 保证在子进程终止前,父进程不会终止*/exit(0);}else{if(p2=fork()){lockf(1,1,0);for(i=0;i<500;i++)printf("son %d\n",i);lockf(1,0,0);wait(0); /* 保证在子进程终止前,父进程不会终止*/exit(0);}else{lockf(1,1,0);for(i=0;i<500;i++)printf("daughter %d\n",i);lockf(1,0,0);exit(0);}}}<运行结果〉输出parent块,son块,grandchild块的顺序可能不同,但是每个块的输出过程不会被打断。
分析:因为上述程序执行时,lockf(1,1,0)锁定标准输出设备,lockf(1,0,0)解锁标准输出设备,在lockf(1,1,0)与lockf(1,0,0)中间的for循环输出不会被中断,加锁与不加锁效果不相同。
3.软中断通信〈任务1〉编制一段程序,使用系统调用fork()创建两个子进程,再用系统调用signal()让父进程捕捉键盘上来的中断信号(即按ctrl+c键),当捕捉到中断信号后,父进程用系统调用kill()向两个子进程发出信号,子进程捕捉到信号后,分别输出下列信息后终止:child process1 is killed by parent!child process2 is killed by parent!父进程等待两个子进程终止后,输出以下信息后终止:parent process is killed!<程序流程图>〈程序〉#include<stdio.h>#include<signal.h>#include<unistd.h>void waiting(),stop(),alarming();int wait_mark;main(){int p1,p2;if(p1=fork()) /*创建子进程p1*/{if(p2=fork()) /*创建子进程p2*/{wait_mark=1;signal(SIGINT,stop); /*接收到^c信号,转stop*/signal(SIGALRM,alarming);/*接受SIGALRM*/waiting();kill(p1,16); /*向p1发软中断信号16*/kill(p2,17); /*向p2发软中断信号17*/wait(0); /*同步*/wait(0);printf("parent process is killed!\n");exit(0);}else{wait_mark=1;signal(17,stop);signal(SIGINT,SIG_IGN); /*忽略^c信号*/while (wait_mark!=0);lockf(1,1,0);printf("child process2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else{wait_mark=1;signal(16,stop);signal(SIGINT,SIG_IGN); /*忽略^c信号*/while (wait_mark!=0)lockf(1,1,0);printf("child process1 is killed by parent!\n");lockf(1,0,0);exit(0);}void waiting(){sleep(5);if (wait_mark!=0)kill(getpid(),SIGALRM);}void alarming(){wait_mark=0;}void stop(){wait_mark=0;}<运行结果>不做任何操作等待五秒钟父进程回在子进程县推出后退出,并打印退出的顺序;或者点击ctrl+C后程序退出并打印退出的顺序。
〈任务2〉在上面的任务1中,增加语句signal(SIGINT,SIG_IGN)和语句signal(SIGQUIT,SIG_IGN),观察执行结果,并分析原因。
这里,signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN)分别为忽略键信号以及忽略中断信号。
<程序>#include<stdio.h>#include<signal.h>#include<unistd.h>int pid1,pid2;int EndFlag=0;int pf1=0;int pf2=0;void IntDelete(){kill(pid1,16);kill(pid2,17);}void Int1(){printf("child process 1 is killed !by parent\n");exit(0);}void Int2(){printf("child process 2 is killed !by parent\n");exit(0);}main(){int exitpid;if(pid1=fork()){if(pid2=fork()){signal(SIGINT,IntDelete);waitpid(-1,&exitpid,0);waitpid(-1,&exitpid,0);printf("parent process is killed\n");exit(0);}else{signal(SIGINT,SIG_IGN);signal(17,Int2);pause();}}else{signal(SIGINT,SIG_IGN);signal(16,Int1);pause();}}〈运行结果〉请将上述程序输入计算机后,执行并观察。