操作系统实验报告-构造进程家族树

合集下载

操作系统进程的创建实验报告

分析showdetail()函数流程图如下：
分析main（）函数流程图如下：
三、.思考题
1)进程创建的核心内容是什么？
答：内容是：1、申请空白PCB 2、为新进程分配资源
3、初始化进程控制块4、将新进程插入到就绪队列
2)该设计和实际的操作系统进程创建相比，缺少了哪些步骤？
答缺少的步骤有：只是模拟的创建，并没有分配资源
只是模拟的创建并没有分配资源四实验总结通过本次实验让我对进程的创建有更深的理解是我真真切切的理解到进程和程序的本质区别
一、实验内容
树形图1：
树形图1分析：进程1、2、3是根进程的子进程，相反的根进程是进程1、2、3的父进程，他们分别对应的优先级为2、2、2；接下来进程4、5又是进程1的子进程，进程6、7是进程2的子进程，进程8是进程3的子进程。
四、实验总结
通过本次实验，让我对进程的创建有更深的理解，是我真真切切的理解到进程和程序的本质区别。学会了如何使用基本命令进行调试和运行程序。总之这让我受益非浅。
各个方面都很符合要求,完成很好,体会写得很深入,继续努力ing。
输入如下：
createpc(1,0,2)
createpc(2,0,2)
createpc(3,0,2)
createpc(4,2,3)
createpc(5,2,3)
createpc(6,2,3)
createpc(7,5,3)
createpc(8,5,3)
运行截图如下：
二、函数分析：
分析createpc(para)函数流程图如下：
输入如下：
createpc(1,0,2)
createpc(2,0,2)
createpc(3,0,2)
createpc(4,0,2)

《操作系统》实验报告

一、实验目的1. 理解进程的概念及其在操作系统中的作用。

2. 掌握进程的创建、调度、同步和通信机制。

3. 学习使用进程管理工具进行进程操作。

4. 提高对操作系统进程管理的理解和应用能力。

二、实验环境1. 操作系统：Windows 102. 软件环境：Visual Studio 20193. 实验工具：C++语言、进程管理工具（如Task Manager）三、实验内容1. 进程的创建与销毁2. 进程的调度策略3. 进程的同步与互斥4. 进程的通信机制四、实验步骤1. 进程的创建与销毁（1）创建进程使用C++语言编写一个简单的程序，创建一个新的进程。

程序如下：```cpp#include <iostream>#include <windows.h>int main() {// 创建进程STARTUPINFO si;PROCESS_INFORMATION pi;ZeroMemory(&si, sizeof(si));si.cb = sizeof(si);ZeroMemory(&pi, sizeof(pi));// 创建进程if (!CreateProcess(NULL, "notepad.exe", NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {std::cout << "创建进程失败" << std::endl;return 1;}std::cout << "进程创建成功" << std::endl;// 等待进程结束WaitForSingleObject(pi.hProcess, INFINITE);// 销毁进程CloseHandle(pi.hProcess);CloseHandle(pi.hThread);return 0;}```（2）销毁进程在上面的程序中，通过调用`WaitForSingleObject(pi.hProcess, INFINITE)`函数等待进程结束，然后使用`CloseHandle(pi.hProcess)`和`CloseHandle(pi.hThread)`函数销毁进程。

实验2 进程控制

实验二进程控制1.学时：2，课外学时8。

2.实验类型：设计性实验3.实验目的：(1)加深对进程概念的理解，明确进程与程序的区别。

(2)进一步认识并发执行的实质。

(3)分析进程争用资源的现象，学习解决进程互斥的方法。

(4)熟悉linux下gcc工具的使用4.实验内容：题目一 4个fork。

写出以下程序输出结果，并画出进程家族树(必须编号)。

#include <unistd.h>int main(void){fork();fork();fork();fork();putchar('A');}题目二父进程不创建孙子进程。

如果父进程需要创建3子进程，但不想创建孙子进程。

编写程序，并画出进程家族树。

题目三父进程创建4个进程。

如果父进程需要创建4个进程，画出所有可能进程家族树。

题目四进程创建。

编写一段程序，使用系统调用fork()创建两个子进程。

当此程序运行时，在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符：父进程显示“a“；两个子进程分别显示字符”b“和字符“c”。

试观察记录屏幕上的显示结果，并分析原因。

题目五子进程利用exec函数执行特定操作。

用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容；利用wait( )来控制进程执行顺序。

5.实验指导一）所涉及的系统调用1.fork( )创建一个新进程。

系统调用格式：pid=fork( )参数定义：fork( )返回值意义如下：0：在子进程中，pid变量保存的fork( )返回值为0，表示当前进程是子进程。

>0：在父进程中，pid变量保存的fork( )返回值为子进程的id值（进程唯一标识符）。

-1：创建失败。

如果fork( )调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。

此时OS在内存中建立一个新进程，所建的新进程是调用fork( )父进程（parent process）的副本，称为子进程（child process）。

操作系统第二次实验报告——Linux创建进程及可执行文件结构分析

操作系统第⼆次实验报告——Linux创建进程及可执⾏⽂件结构分析0 个⼈信息张樱姿201821121038计算18121 实验⽬的熟练Linux创建进程fork操作。

2 实验内容在服务器上⽤VIM编写⼀个程序：⼀个进程创建两个⼦进程。

查看进程树查看进程相关信息3 实验报告　3.1编写程序创建两个⼦进程1 #include<sys/types.h>2 #include<stdio.h>3 #include<unistd.h>45int main(){6 pid_t cpid1 = fork(); //创建⼦进程178if(cpid1<0){9 printf("fork cd1 failed\n");10 }11else if(cpid1==0){12 printf("Child1:pid: %d, ppid: %d\n",getpid(),getppid());13 }14else{15 pid_t cpid2 = fork(); //创建⼦进程216if(cpid2<0){17 printf("fork cd2 failed\n");18 }19else if(cpid2==0){20 printf("Child2:pid: %d, ppid: %d\n",getpid(),getppid());21 }22else{23 printf("Parent: pid :%d\n",getpid());24 }25 }26 }编译运⾏后的结果：3.2打印进程树　添加sleep函数以挂起进程，⽅便打印进程树：1 #include<sys/types.h>2 #include<stdio.h>3 #include<unistd.h>45int main(){6 pid_t cpid1 = fork();78if(cpid1<0){9 printf("fork cd1 failed\n");10 }11else if(cpid1==0){12 printf("Child1:pid: %d, ppid: %d\n",getpid(),getppid());13 sleep(30); //挂起30秒14 }15else{16 pid_t cpid2 = fork();17if(cpid2<0){18 printf("fork cd2 failed\n");19 }20else if(cpid2==0){21 printf("Child2:pid: %d, ppid: %d\n",getpid(),getppid());22 sleep(30); //挂起30秒23 }24else{25 printf("Parent: pid :%d\n",getpid());26 sleep(60); //挂起60秒27 }28 }29 }pstree -p pid #打印进程树 3.3 解读进程相关信息 3.3.1 解释执⾏ps -ef后返回结果中每个字段的含义 ps -ef输出格式 :UID PID PPID C STIME TTY TIME CMDUID: User ID，⽤户ID。

Linux进程家族树(上海大学操作系统研讨)

服务——常驻在内存的进程
↑ P P I D
↑ P I D
↑ 进程组 P G I D
↑ 会话 S I D
↑ T T Y
↑ T P G I D
↑ 状态
↑ U I D
↑ COMMAND
父进程如何产生子进程
<中间暂存进程> PID=x 程序=zzz <父进程> ①复制一个与父进程相同的暂存进程(PID不同,PPID指向父进程) ②暂存进程以exec方式加载实际要执行的程序 fork PPID=x PID=y 程序=zzz exec qqq
有关Linux进程树
刘知昊 /SHU15121856
PCB(进程控制块)
状态信息——>> PC(指令计数器)——>> 上下文信息——>> <<——I/O状态信息核算信息——>> <<——PID(进程标识符) <<——进程优先级 <<——存储器指针
ps命令查看进程
pstree命令查看进程树
进程的主体和客体
主体客体
主体是一个主动的实体，包括用户、用户组、进程等。系统中最基本的主体应该是用户。
客体是一个被动的实体。在操作系统中，客体可以是按照一定格式存储在一定记录介质上的数据信息，也可以是操作系统中的进程。
服务者是要求者的客体，要求者是服务者的主体，而最原始的主体是用户，最终的客体是一定记录介质上的信息。
2
3
多用户状态(没有NFS)
完全的多用户状态(有NFS)，登陆后进入控制台命令行模式
4
5 6
系统未使用，保留
X11控制台，登陆后进入图形GUI模式系统正常关闭并重启，默认运行级别不能设为6，否则不能正常启动

操作系统进程创建父子进程实验报告

2009-2010学年第一学期专业：网络工程班级：071022学号：07102210姓名：刘辰龙提交日期：2009.12.04实验一、Linux进程创建与进程通信【实验目的】1. 熟悉有关Linux系统调用；2. 学习有关Linux的进程创建，理解进程创建后两个并发进程的执行；3. 通过系统调用wait()和exit()，实现父子进程同步；4. 掌握管道、消息缓冲等进程通信方法并了解其特点和使用限制。

【实验程序及分析】1. 父进程创建子进程实现父进程创建一个子进程，返回后父子进程分别循环输出字符串“The parent process.”及“The child process.”5次，每次输出后使用sleep(1)延时一秒，然后再进入下一次循环。

给出源程序代码和运行结果。

程序代码：#include<stdio.h>main(){int p,i;while((p=fork())==-1); //创建子进程直至成功if(p==0) //子进程返回{for(i=0;i<5;i++){printf("The child process!\n");sleep(1); //延时1秒}}else{ //父进程返回for(i=0;i<5;i++){printf("The parent process!\n");sleep(1); //延时1秒}}}运行结果：2.父子进程同步修改上题程序，使用exit()和wait()实现父子进程同步，其同步方式为父进程等待子进程的同步，即：子进程循环输出5次，然后父进程再循环输出5次。

给出源程序代码和运行结果。

程序代码：#include<stdio.h>main(){int p,i;while((p=fork())==-1); //创建子进程直至成功if(p>0) //返回父进程{wait(0); //父进程等待子进程终止for(i=0;i<5;i++){printf("The parent process!\n");sleep(1); //延时1秒}}else //返回子进程{for(i=0;i<5;i++){printf("The child process!\n");sleep(1);}exit(0); //子进程向父进程发终止信号0 }}运行结果：3. Linux管道通信编写一个程序，实现以下功能。

实验六：构造进程家族树、理解进程的独立空间

评语: 课中检查完成的题号及题数：课后完成的题号与题数：成绩: 指导教师:实验报告实验名称：五构造进程家族树六理解进程的独立空间日期：2011.5.16一、实验目的1.构造进程家族树通过创建若干个子进程，构造进程家族树，分析进程家族树的结构关系；学习相关系统调用（例如，getpid（）和getppid（）等）的使用方法。

2. 理解进程的独立空间理解进程是操作系统独立分配资源的单位，进程拥有自己相对独立的程序空间。

二、实验内容1. 构造进程家族树学习进程构造的相关知识，学习获取进程相关信息的系统调用函数。

2. 理解进程的独立空间预习进程创建和构造的相关知识，了解C语言程序编写的相关知识。

三、项目要求及分析1. 构造进程家族树进程的创建。

编制一段程序，使用系统调用fork()创建三个子进程，在各个子进程中再使用系统调用fork()进一步创建子进程，如此重复，构造一棵具有图1形状的进程家族树。

分别使用系统调用getpid（）和getppid（）获取当前进程和父进程的进程标识号并输出。

2. 理解进程的独立空间a. 编写一个程序，在其main （）函数中定义一个变量shared ，对其进行循环加/减操作，并输出每次操作后的结果；b. 使用系统调用fork （）创建子进程，观察该变量的变化；c. 修改程序把shared 变量定义到main （）函数之外，重复第（2）步操作，观察该变量的变化。

四、具体实现1. 流程图a. 构造进程家族树ParentPid2 Pid1Pid3Pid12Pid11b. 理解进程的独立空间2. 添加函数的代码结束开始调用父进程，执行shared输出shared 值调用子进程，执行shared输出shared 值>0 =0 =0=0 >0=0 打印创建子进程Pid11 Pid11=0? 创建子进程Pid12 打印 Pid11=0?开始创建子进程Pid1Pid1=0?创建子进程Pid2Pid2=0?创建子进程Pid3 Pid3=0?结束 >0>0=0a.构造进程家族树b.理解进程的独立空间五、调试运行结果1.实验5:2.实验6:六、所遇问题及解决方法在构造家族树的时候考虑pid不全面，编程的时候因为对进程理解不到位而产生生成多个父进程。

Linux操作系统实验--进程

Linux操作系统实验--进程Linux操作实验实验目的：1. 了解有关Linux进程的属性；2. 学习有关Linux的前台、后台进程及守护进程；3. 学习有关Linux命令的顺序执行和并发执行；4. 学习有关挂起和终止进程；5. 了解Linux的信号。

6. 了解你系统中Linux进程的层次结构。

实验内容：实验用到的命令：ps、kill、nice、pstree等1. 进入你的 linux系统2. 在你进入系统中，有多少进程在运行？进程init、sched、cron、inetd的ID是多少。

给出你得到这些信息的会话过程。

3. init、sched、cron和inetd进程的父进程是哪一个？这些父进程的ID是什么？init、sched、cron和inetd进程的优先数是多少？根据优先数从高到低（大到小）列出这些进程。

给出会话过程。

4. 你系统中有多少个HTTP服务进程？它们的进程ID是什么？获得上面每个信息用一个命令实现。

给出你的会话过程。

5. 有多少个sh、bash、csh和tcsh进程运行在你的系统中？给出会话过程。

6. linux系统中，进程可以在前台或后台运行。

前台进程在运行结束前一直控制着终端。

若干个命令用分号（；）分隔形成一个命令行，用圆括弧把多个命令挂起来，他们就在一个进程里执行。

使用“&”符作为命令分隔符，命令将并发执行。

可以在命令行末尾加“&”使之成为后台命令。

请用一行命令实现以下功能，它一小时后再屏幕上显示文字“Time for Lunch!”来提醒你去吃午餐。

给出会话过程。

注：可以使用sleep命令7. 写一个命令行，实现find 和sort 命令的并发执行。

find命令显示在你的主目录下foobar文件的路径；sort 命令以GPA作为关键字排序smallFile 文件，且忽略字段间的空格。

两个命令的错误信息重定向到/dev/null中。

find命令的输出重定向到find.out 文件中，sort 命令的输出重定向到sort.out文件中。

树的操作实验报告

实验名称：树的操作实验实验目的：1. 理解树的基本概念和操作。

2. 掌握树的创建、插入、删除、查找等基本操作。

3. 熟悉树在计算机科学中的应用。

实验环境：1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse实验内容：1. 树的基本概念2. 树的创建3. 树的插入4. 树的删除5. 树的查找6. 树的应用实验步骤：一、树的基本概念1. 树的定义：树是一种非线性数据结构，由若干节点组成，每个节点有一个唯一的父节点（根节点除外），除了根节点外，其他节点都有一个子节点。

2. 树的术语：- 节点：树中的数据元素。

- 父节点：节点的直接前驱节点。

- 子节点：节点的直接后继节点。

- 根节点：没有父节点的节点。

- 叶节点：没有子节点的节点。

- 节点的度：节点拥有的子节点个数。

- 树的深度：根节点到叶节点的最长路径长度。

二、树的创建1. 创建二叉树：```javapublic class BinaryTree {private TreeNode root;public BinaryTree() {root = null;}public void createTree(int[] data) {if (data == null || data.length == 0) {return;}root = new TreeNode(data[0]);int i = 1;Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root);while (!queue.isEmpty()) {TreeNode node = queue.poll();if (i < data.length && data[i] != 0) {node.left = new TreeNode(data[i]); queue.offer(node.left);i++;}if (i < data.length && data[i] != 0) { node.right = new TreeNode(data[i]); queue.offer(node.right);i++;}}}}```2. 创建二叉搜索树：```javapublic class BinarySearchTree {private TreeNode root;public BinarySearchTree() {root = null;}public void createTree(int[] data) {if (data == null || data.length == 0) {return;}for (int i = 0; i < data.length; i++) {root = insert(root, data[i]);}}private TreeNode insert(TreeNode node, int data) { if (node == null) {return new TreeNode(data);}if (data < node.data) {node.left = insert(node.left, data);} else if (data > node.data) {node.right = insert(node.right, data);}return node;}}```三、树的插入1. 在二叉树中插入节点：```javapublic void insert(TreeNode node, int data) {if (node == null) {return;}if (data < node.data) {insert(node.left, data);} else if (data > node.data) {insert(node.right, data);}}```2. 在二叉搜索树中插入节点：```javaprivate TreeNode insert(TreeNode node, int data) { if (node == null) {return new TreeNode(data);}if (data < node.data) {node.left = insert(node.left, data);} else if (data > node.data) {node.right = insert(node.right, data);}return node;}```四、树的删除1. 在二叉树中删除节点：```javapublic void delete(TreeNode node, int data) {if (node == null) {return;}if (data < node.data) {delete(node.left, data);} else if (data > node.data) {delete(node.right, data);} else {if (node.left == null && node.right == null) { node = null;} else if (node.left == null) {node = node.right;} else if (node.right == null) {node = node.left;} else {TreeNode minNode = findMin(node.right);node.data = minNode.data;delete(node.right, minNode.data);}}}```2. 在二叉搜索树中删除节点：```javaprivate TreeNode delete(TreeNode node, int data) {if (node == null) {return null;}if (data < node.data) {node.left = delete(node.left, data);} else if (data > node.data) {node.right = delete(node.right, data);} else {if (node.left == null && node.right == null) { node = null;} else if (node.left == null) {node = node.right;} else if (node.right == null) {node = node.left;} else {TreeNode minNode = findMin(node.right);node.data = minNode.data;node.right = delete(node.right, minNode.data); }}return node;}```五、树的查找1. 在二叉树中查找节点：```javapublic TreeNode search(TreeNode node, int data) {if (node == null) {return null;}if (data == node.data) {return node;} else if (data < node.data) {return search(node.left, data);} else {return search(node.right, data);}}```2. 在二叉搜索树中查找节点：```javapublic TreeNode search(TreeNode node, int data) {if (node == null) {return null;}if (data == node.data) {return node;} else if (data < node.data) {return search(node.left, data);} else {return search(node.right, data);}}```六、树的应用1. 堆排序：利用二叉堆的属性，实现高效排序。

树的建立实验报告

树的建立实验报告摘要本实验旨在通过构建树的过程，深入理解树的概念、特性及基本操作。

通过实验，我们学习了如何根据给定的数据构建一棵树，并实现树的遍历和查找操作。

同时，通过实验，我们也发现了树这种数据结构在实际应用中的重要性和灵活性。

1. 实验目的1. 掌握树的定义、基本概念和基本操作；2. 学习树的构建和遍历算法；3. 了解树在实际应用中的应用。

2. 实验设备和材料- 计算机- 编程环境：Python、Java或其他编程语言3. 实验方法1. 学习树的定义、基本概念和基本操作；2. 根据给定的数据，构建一棵树；3. 实现树的遍历算法，包括前序遍历、中序遍历和后序遍历；4. 实现树的查找操作；5. 进行实验结果的验证和分析。

4. 实验过程1. 根据给定数据构建一棵树。

我们选取一个文本文件作为输入，文件中每一行代表一个节点，并用空格分隔节点和其父节点。

根据这些信息，可以构建一棵树。

2. 实现树的建立操作，通过读取文本文件，逐行构建树的节点，并将节点关系保存在合适的数据结构中。

3. 实现树的遍历算法。

我们选择实现前序遍历、中序遍历和后序遍历算法。

通过递归方式，对树进行遍历，并将结果输出。

4. 实现树的查找操作。

给定一个节点值，通过遍历树，找到并输出对应的节点。

5. 实验结果1. 根据给定数据，构建了一棵树。

树的结构如下所示：A/ \B C/ \ / \D E F G2. 实现了树的遍历算法，结果如下：- 前序遍历结果：A -> B -> D -> E -> C -> F -> G- 中序遍历结果：D -> B -> E -> A -> F -> C -> G- 后序遍历结果：D -> E -> B -> F -> G -> C -> A3. 实现了树的查找操作。

通过给定节点值，可以找到对应的节点。

Linux实验总结分析报告

Linux实验总结分析报告Linux体系架构Linux操作系统主要涉及⽂件管理、内存管理、进程管理、系统中断等等。

进程管理Linux进程的存在两种运⾏模式，在Linux⾥，⼀个进程既可以运⾏⽤户程序，⼜可以运⾏操作系统程序。

当进程运⾏⽤户程序时，称其为处于“⽤户模式”；当进程运⾏时出现了系统调⽤或中断事件，转⽽去执⾏操作系统内核的程序时，称其为处于“核⼼模式”。

在Linux⾥处理机就具有两种运⾏状态：核⼼态和⽤户态。

Linux下进程概念及特征：（1）、在Linux⾥，把进程定义为“程序运⾏的⼀个实例”（2）、进程⼀⽅⾯竞争并占⽤系统资源（⽐如设备和内存），向系统提出各种请求服务；进程另⼀⽅⾯是基本的调度单位，任何时刻只有⼀个进程在CPU上运⾏。

Linux进程实体的组成：Linux中，每个进程就是⼀个任务（task），⼀般具有以下四个部分：（1）进程控制块（在Linux⾥，也称为进程描述符。

）。

（2）进程专⽤的系统堆栈空间；（3）供进程执⾏的程序段（在Linux⾥，称为正⽂段）；（4）进程专⽤的数据段和⽤户堆栈空间Linux的进程控制块——进程描述符在Linux中，进程的进程描述符是⼀个结构类型的数据结构：task_struct。

进程描述符组成内容进程标识（pid）；进程状态（state）；进程调度信息，包括调度策略（policy）、优先级别（priority和rt_priority）、时间⽚（counter）等；接收的信号（*sig）；进程家族关系；进程队列指针； CPU的现场保护区；与⽂件系统有关的信息。

Linux的进程状态 Linux的进程可以有五种不同的状态进程状态：可运⾏状态可中断状态不可中断状态暂停状态僵死状态进程的创建与撤销：Linux中的每个进程，都有⼀个创建、调度运⾏、撤销死亡的⽣命期。

Linux系统中的各个进程，相互之间构成了⼀个树型的进程族系。

Linux的进程调度类型：在Linux中，进程调度被分为实时进程调度和⾮实时进程调度两种。

操作实验3

四. 实验内容及步骤1. 编写程序。

显示进程的有关标识（进程标识、组标识、用户标识等）。

经过5 秒钟后，执行另一个程序，最后按用户指示（如：Y/N）结束操作。

2. 参考例程1，编写程序。

实现父进程创建一个子进程。

体会子进程与父进程分别获得不同返回值，进而执行不同的程序段的方法。

思考：子进程是如何产生的？又是如何结束的？子进程被创建后它的运行环境是怎样建立的？答:是由父进程用fork()函数创建形成的，通过exit()函数自我结束，子进程被创建后核心将其分配一个进程表项和进程标识符，检查同时运行的进程数目，并且拷贝进程表项的数据，由子进程继承父进程所有文件。

3. 参考例程2，编写程序。

父进程通过循环语句创建若干子进程。

探讨进程的家族树以及子进程继承父进程的资源的关系。

思考题：①画出进程的家族树。

子进程的运行环境是怎样建立的？反复运行此程序看会有什么情况？解释一下。

②修改程序，使运行结果呈单分支结构，即每个父进程只产生一个子进程。

画出进程树，解释该程序。

2.修改之后的程序运行结果：解释：当该进程为父进程时就创建子进程并退出，当该进程为子进程时返回标识号4. 参考例程3 编程，使用fork( )和exec( )等系统调用创建三个子进程。

子进程分别启动不同程序，并结束。

反复执行该程序，观察运行结果，结束的先后，看是否有不同次序。

思考：子进程运行其它程序后，进程运行环境怎样变化的？反复运行此程序看会有什么情况？解释一下。

答：子进程运行其他程序后，这个进程就完全被新程序代替。

由于并没有产生新进程所以进程标识号不改变，除此之外的旧进程的其他信息，代码段，数据段，栈段等均被新程序的信息所代替。

新程序从自己的main()函数开始进行。

反复运行此程序发现结束的先后次序是不可预知的，每次运行结果不一样。

原因是当每个子进程运行其他程序时，他们的结束随着其他程序的结束而结束，所以结束的先后次序在改变。

5. 参考例程4编程，验证子进程继承父进程的程序、数据等资源。

操作系统进程创建父子进程实验报告

给出源程序代码和运行结果。

上海大学操作系统实验报告三

SHANGHAI UNIVERSITY 《操作系统（一）》实验报告学院计算机工程与科学学院姓名吴学辉报告序号三实验题目进程管理及进程通信日期2016.11.1《操作系统（一）》实验报告一、实验目的与要求1. 利用Linux提供的系统调用设计程序，加深对进程概念的理解。

2. 体会系统进程调度的方法可效果。

3. 了解进程之间的通信方式以及各种通信方式的使用二、实验环境Linux Ubuntu系统三、实验内容实验方法：用vi编写C程序（假定程序文件名为prog1.c）编写程序$ gcc –o prog1.o prog1.o （编译prog1.c产生输出的目标程序prog1.o）或$ cc -o prog1.o prog1.c运行$./prog1.o操作过程：1.编写程序。

显示进程的有关标识（进程标识、组标识、用户标识等）。

经过5 秒钟后，执行另一个程序，最后按用户指示（如：Y/N）结束操作。

2.参考例程1，编写程序。

实现父进程创建一个子进程。

体会子进程与父进程分别获得不同返回值，进而执行不同的程序段的方法。

3.参考例程2，编写程序。

父进程通过循环语句创建若干子进程。

探讨进程的家族树以及子进程继承父进程的资源的关系。

思考题：①画出进程的家族树。

子进程的运行环境是怎样建立的？反复运行此程序看会有什么情况？解释一下。

②修改程序，使运行结果呈单分支结构，即每个父进程只产生一个子进程。

画出进程树，解释该程序。

2.修改之后的程序运行结果：解释：当该进程为父进程时就创建子进程并退出，当该进程为子进程时返回标识号4.参考例程3 编程，使用fork( )和exec( )等系统调用创建三个子进程。

操作系统实验报告三

课程实验报告3、修改程序1，在父、子进程中分别使用wait、exit等系统调用“实现”其同步推进，父进程必须等待儿子进程与女儿进程结束，才可以输出消息。

写出相应的同步控制，并分析运行结果。

4、创建一个子进程，并给它加载程序，其功能是调用键盘命令“ls -l”，已知该键盘命令的路径与文件名为：/bin/ls。

父进程创建子进程，并加载./child2程序。

写出相应的程序代码并分析程序运行结果。

算法描述及实验步骤1、编写一C语言程序，实现在程序运行时通过系统调用fork( )创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“I am father”，儿子进程执行时屏幕显示“I am son”，女儿进程执行时屏幕显示“I amdaughter”。

并且反复的测试，观察每一次的执行的顺序有什么不同2、修改程序1，在父、子进程中分别使用wait、exit等系统调用“实现”其同步推进，父进程必须等待儿子进程与女儿进程结束，才可以输出消息。

4、创建一个子进程，并给它加载程序，其功能是调用键盘命令“ls -l”，已知该键盘命令的路径与文件名为：/bin/ls。

父进程创建子进程，并加载./child2程序。

调试过程及实验结果总结1、实现在程序运行时通过系统调用fork( )创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“I am father”，儿子进程执行时屏幕显示“I am son”，女儿进程执行时屏幕显示“I am daughter”。

这一点需要注意。

返回结果时，由于每一次的不确定性，所以要想得到比较具有说服性的，就必须经过多次的测试。

2、连续4个fork()的进程家族树在进行实验的时候可能会出现进程输出信息一直一样的情况，需要多次执行输出才有可能会看到输出结果不一样的情况。

操作系统第2次实验报告：创建进程

操作系统第2次实验报告：创建进程姓名：王丕杰学号：201821121052班级：计算1812⼀、实验⽬的熟练Linux创建进程fork操作。

⼆、实验内容在服务器上⽤VIM编写⼀个程序：⼀个进程创建两个⼦进程。

查看进程树查看进程相关信息三、实验报告1、编写程序在服务器上⽤VIM编辑器编写⼀个程序：⼀个进程创建（fork）两个⼦进程。

程序命名为 forktest.c给出源代码：1 #include<stdio.h>2 #include<sys/types.h>3 #include<unistd.h>4 int main ()5 {6 pid_t fpid;7 for(int i=0;i<2;i++){8 fpid=fork();9 if(pid==0||pid==-1){10 break;11 }12 }13 if(fpid==0){14 printf("Child proces: %d\n",getpid());15 }16 else if(fpid==-1){17 printf("error\n");18 }19 else{20 printf("Parent process: %d\n",getpid());21 }22 sleep(200);23 return 0;24 }2、打印进程树编译程序并运⾏：打印进程树：3、解读进程相关信息(1) ps -ef相应字段解析：UID：⽤户ID（此处为wangpijie）PID：进程ID（此处为4173、4174、4175等）PPID：该进程的⽗进程ID（例如⼦进程4174、4175对应其⽗进程4173）C：该进程占⽤CPU的百分⽐（此处为0）STIME：进程开始时间（此处为11:33）TTY：登录进程终端机位置（此处为pts/1）TIME：进程运⾏时间（此处为00:00:00）CMD：运⾏该进程所下达的指令（此处为 ./forktest）(2) ps -aux相应字段解析：USER：⽤户名（此处为wangpijie）PID：进程ID（此处为4173、4174、4175等）%CPU：CPU占⽐（0.0）%MEN：内存占⽐（0.0）VSZ：占⽤虚拟记忆体的⼤⼩RSS：占⽤记忆体的⼤⼩TTY：登录进程终端机位置（此处为pts/1）STAT：进程状态（此处S表⽰中断，显⽰S+是因为包括⼦进程）START：进程开始时间（此处为11:33）TIME：进程运⾏时间（此处为0:00）COMMAND：运⾏该进程所下达的指令（此处为 ./forktest）4、通过该实验产⽣新的疑问及解答疑问：实验过程中在运⾏程序后，执⾏pstree -p pid仍⽆法打印出进程树解答：（1）需要打开两个终端窗⼝，⼀个运⾏程序，⼀个执⾏ pstree -p pid 打印进程树（2）程序中sleep()挂起进程的时间太短，导致进程树⽆法打印，增加挂起进程的时间即可。