操作系统B2-上机实验-进程
上海大学操作系统(二)实验报告(全)
评分：SHANGHAI UNIVERSITY操作系统实验报告学院计算机工程与科学专业计算机科学与技术学号学生姓名《计算机操作系统》实验一报告实验一题目：操作系统的进程调度姓名：张佳慧学号 :12122544 实验日期： 2015.1实验环境： Microsoft Visual Studio实验目的：进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。
本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。
调度算法可任意选择或自行设计。
例如，简单轮转法和优先数法等。
本实习可加深对于进程调度和各种调度算法的理解。
实验内容：1、设计一个有n个进程工行的进程调度程序。
每个进程由一个进程控制块（PCB）表示。
进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。
2、调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。
3、系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程。
操作过程：1、本程序可选用优先数法或简单轮转法对五个进程进行调度。
每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假设起始状态都是就绪状态W。
为了便于处理，程序进程的运行时间以时间片为单位计算。
进程控制块结构如下：进程控制块结构如下：PCB进程标识数链指针优先数/轮转时间片数占用 CPU 时间片数进程所需时间片数进程状态进程控制块链结构如下：其中：RUN—当前运行进程指针；HEAD—进程就绪链链首指针；TAID—进程就绪链链尾指针。
2、算法与框图(1) 优先数法。
进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。
每过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也减 3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。
操作系统实验二实验报告
操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术，包括进程的创建、执行、同步和通信。
通过实际编程和实验操作，提高对操作系统原理的认识，培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容及步骤（一）进程创建实验1、首先，创建一个新的 C+＋项目。
2、在项目中，使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束，并获取其退出代码。
（二）进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区，当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理，当缓冲区为空时等待。
（三）进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道，父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据，子进程从管道读取数据并进行处理。
四、实验结果及分析（一）进程创建实验结果成功创建了新的进程，并能够获取到其退出代码。
通过观察进程的创建和执行过程，加深了对进程概念的理解。
（二）进程同步实验结果通过使用信号量，生产者和消费者进程能够正确地进行同步，避免了缓冲区的溢出和数据的丢失。
分析结果表明，信号量机制有效地解决了进程之间的资源竞争和协调问题。
（三）进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递，验证了管道通信的有效性。
五、遇到的问题及解决方法（一）在进程创建实验中，遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试，最终正确设置了参数，成功创建了进程。
（二）在进程同步实验中，出现了信号量使用不当导致死锁的情况。
操作系统实验报告_进程部分
西安邮电学院操作系统实验报告专业名称：软件工程班级：软件0701 学号：04075021 学生姓名：孟阿龙实验1 掌握Linux基本命令和开发环境1.掌握常用的Linux shell命令；掌握linux下的基本命令的用法。
ls，cat，mkdir，rm，touch，less，cp,mv,head,tail,sort,echo2. 掌握编辑环境VIM；学习vim的基本使用。
i，a：进入编辑模式v：进入可视模式esc；进入命令模式编辑模式下可以和正常的文本输入方式一样。
V进入可视模式可以使用y进行复制，d进行剪切，p进行粘贴。
esc进入命令模式可以w进行文件存盘，q退出vim，q！不保存而退出，u撤销。
3. 掌握编译环境gcc及跟踪调试工具gdbgcc编译文件的格式gcc －o 目标文件源文件gcc 源文件gcc -g －o 目标文件源文件gdb基本调试命令：l：列出当前文件b linenumber，在指定的行设置断点Info br 查看断点信息Info source 查看源码信息Info stack 查看堆栈信息Info args 查看当前的参数List function 列出某个函数disable／enable 使断点失效或有效delete 删除断点step 单步执行命令print a :打印出变量a的内容实验二进程一实验目的：通过观察分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握fork和kill系统调用的功能和使用。
二实验前准备：学习man 命令的用法，通过它查看fork 和kill 系统调用的在线帮助，并阅读参考资料学会fork 与kill 的用法。
复习C 语言的相关内容。
三实验内容：按照所给的残缺版代码读懂程序，然后回答问题。
（残缺版实验代码略）1.先猜想一下这个程序的运行结果。
假如运行“./process 20”，输出会是什么样？将会产生10个进程。
因为程序设定最大产生进程数为10。
操作系统实验报告
《操作系统》课程实验报告专业：软件工程班级：软件二班学号： 2220111350 姓名：韩培培序号： 14目录：实验一、进程的创建实验二、进程控制实验三、进程的管道通信实验四、消息通信实验五、进程调度实验六、FIFO页面调度实验七、LRU页面置换算法实验一进程的创建一．实验目的：进程的创建二．实验内容：编写一段程序，使用系统调用 FORK( )创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“A”子进程分别显示字符“B”和“C”。
试观察记录屏幕上的显示结果，并分析原因。
三．实验代码：#include ＜stdio.h＞Main(){ int p1,p2；While((p1=fork())==-1)；If (p1==0)Putchar(ˊbˊ)；else{While((p2=fork())==-1)；If(p2==0)Putchar(ˊcˊ)；else putchar(ˊaˊ)；}}四．实验运行结果五．分析原因程序首先调用Fork（）函数创建一个子进程1.当创建进程不成功，循环创建进程，直至进程创建成功。
如果Fork（）返回值为0，表示当前进程是子进程1，显示字符B。
如果Fork（）返回值大于0，则表示当前进程是父进程，表示当前的程序代码是父进程所要执行的。
父进程调用Fork（）创建子进程2。
当创建进程不成功时，循环创建进程直至成功。
如果Fork（）返回值为0，则表示当前进程是子进程2，显示字符C。
如果Fork（）返回值大于0，则表示当前进程是父进程，输出字符A。
实验二：进程控制一．实验目的：进程控制二．实验内容：修改已编写的程序，将每个进程的输出由单个字符改为一个字符串，再观察程序的执行时屏幕上出现的现象，并分析原因三．实验代码：# include＜stdio.h＞Main(){ int p1,p2,i;While((p1=fork())== -1);If (p1 == 0)For (i=0;i<500;i++)Printf(＂child %d/n＂,i);else{While((p2 =fork()) == -1);if(p2 == 0)for (i= 0;i<500;i++)printf(＂son%d\n＂,i)elsefor(i = 0;i<500;i++)printf(＂daughter%d\n＂,i);}}四．分析原因：由于函数Printf()输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。
计算机操作系统实验二
计算机操作系统实验二一、实验目的本实验旨在通过实际操作，深入理解和掌握计算机操作系统中的进程与线程管理。
通过实验，我们将了解进程的创建、执行、阻塞、唤醒等状态以及线程的创建、同步、通信等操作。
同时，通过实验，我们将学习如何利用进程和线程提高程序的并发性和效率。
二、实验内容1、进程管理a.进程的创建与执行：通过编程语言（如C/C++）编写一个程序，创建一个新的进程并执行。
观察和记录进程的创建、执行过程。
b.进程的阻塞与唤醒：编写一个程序，使一个进程在执行过程中发生阻塞，并观察和记录阻塞状态。
然后，通过其他进程唤醒该进程，并观察和记录唤醒过程。
c.进程的状态转换：根据实际操作，理解和分析进程的状态转换（就绪状态、阻塞状态、执行状态）以及转换的条件和过程。
2、线程管理a.线程的创建与同步：编写一个多线程程序，创建多个线程并观察和记录线程的创建过程。
同时，使用同步机制（如互斥锁或信号量）实现线程间的同步操作。
b.线程的通信：通过消息队列或其他通信机制，实现多个线程间的通信。
观察和记录线程间的通信过程以及通信对程序执行的影响。
c.线程的状态转换：根据实际操作，理解和分析线程的状态转换（新建状态、就绪状态、阻塞状态、终止状态）以及转换的条件和过程。
三、实验步骤1、按照实验内容的要求，编写相应的程序代码。
2、编译并运行程序，观察程序的执行过程。
3、根据程序的输出和实际操作情况，分析和理解进程与线程的状态转换以及进程与线程管理的相关原理。
4、修改程序代码，尝试不同的操作方式，观察程序执行结果的变化，进一步深入理解和掌握进程与线程管理。
5、完成实验报告，总结实验过程和结果，提出问题和建议。
四、实验总结通过本次实验，我们深入了解了计算机操作系统中的进程与线程管理原理和实践操作。
在实验过程中，我们不仅学习了如何利用编程语言实现进程和线程的操作，还通过实际操作观察和分析了进程与线程的状态转换以及进程与线程管理的基本原理。
操作系统上机实验报告
操作系统上机实验报告实验一进程的建立1.实验目的学会通过基本的Windows进程控制函数，由父进程创建子进程，并实现父子进程协同工作。
2.实验软硬件环境Dev-C++3.实验内容创建两个进程，让子进程读取一个文件，父进程等待子进程读取完文件后继续执行，实现进程协同工作。
进程协同工作就是协调好两个进程，使之安排好先后次序并以此执行，可以用等待函数来实现这一点。
当需要等待子进程运行结束时，可在父进程中调用等待函数。
4.实验程序及分析实验程序源代码如下：父进程：#include<stdio.h>#include<windows.h>int main(){STARTUPINFO si;PROCESS_INFORMA TION pi; //当Windows创建新进程时，将使用这两个结构体的有关成员。
所以在创建子进程之前应该对结构体进行声明和初始化。
ZeroMemory(&pi,sizeof(pi));ZeroMemory(&si,sizeof(si));si.cb=sizeof(STARTUPINFO);if(CreateProcess("lab1.2.exe",NULL,NULL,NULL,FALSE,CREATE_NEW_CONSOLE,NULL ,NULL,&si,&pi))//创建一个新进程，若是成功，就返回1，进而实现if选择{printf("子进程已创建～\n");int i,sum=0;for(i=1;i<=100;++i){sum+=i;printf("sum=%d\n",sum);} //进行1+2+3+….+100计算WaitForSingleObject(pi.hProcess,INFINITE); FILE *fp;fp=fopen("date.txt","r");char ch=fgetc(fp); //创建文件并打开while(ch!=EOF){putchar(ch);ch=fgetc(fp);}fclose(fp); //关闭文件}elseprintf("子进程创建失败～\n");return 0;}子进程：#include<stdio.h>#include<stdlib.h>int main(){printf("子进程运行～\n");FILE *fp;if(fp=fopen("date.txt","w")){printf("已经创建文件!\n");int i;for(i=48;i<58;i++) fputc(i,fp);fputc('\n',fp);fclose(fp);printf("已经写入数据:"); //向文本中写入数据fp=fopen("date.txt","r");char ch=fgetc(fp);while(ch!=EOF){putchar(ch);ch=fgetc(fp); //输出数据}fclose(fp);}else printf("创建文件失败!\n");system("pause");return 0;}5. 实验截图说明及分析6. 实验心得体会掌握了父进程创建子进程的方法，对操作系统多线程认识更深了。
进程操作实验报告
进程操作实验报告进程操作实验报告一、引言进程是计算机系统中最基本的概念之一，它代表了正在运行的程序。
在操作系统中，进程的管理和操作是非常重要的。
本实验旨在通过对进程操作的实践，加深对进程概念的理解，并掌握进程的创建、调度和终止等操作。
二、实验目的1. 理解进程的概念和基本属性；2. 掌握进程的创建和终止操作；3. 熟悉进程调度算法的实现；4. 加深对操作系统中进程管理的理解。
三、实验环境本次实验使用的操作系统为Linux，并且需要具备C语言编程基础。
四、实验内容1. 进程的创建进程的创建是操作系统中的一个重要操作。
通过调用fork()函数，可以在当前进程的基础上创建一个新的子进程。
子进程将继承父进程的资源，包括内存空间、文件描述符等。
通过实验，我们可以编写一个简单的程序，演示进程的创建过程，并观察子进程和父进程的行为差异。
2. 进程的调度进程调度是操作系统中的核心功能之一。
在多任务系统中，操作系统需要合理地分配CPU时间片，以便每个进程都能得到执行的机会。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。
通过实验，我们可以编写一个简单的程序，模拟进程的调度过程，并观察不同调度算法对进程执行顺序的影响。
3. 进程的终止进程的终止是操作系统中的另一个重要操作。
通过调用exit()函数，可以结束当前进程的执行，并释放相关资源。
在实验中，我们可以编写一个程序，演示进程的终止过程，并观察终止进程后系统的行为。
五、实验步骤1. 进程的创建实验步骤：（1）编写一个简单的程序，调用fork()函数创建子进程；（2）在父进程和子进程中分别输出不同的信息，以便观察其行为差异；（3）编译并运行程序，观察输出结果。
2. 进程的调度实验步骤：（1）编写一个简单的程序，模拟多个进程的执行；（2）使用不同的调度算法，如FCFS、SJF、RR等，对进程进行调度；（3）观察不同调度算法对进程执行顺序的影响，并比较它们的优缺点。
操作系统上机实验进程管理
文档编号：第 1 次上机实验操作系统上机实验报告进程管理实验人：学号：095090142011年4 月13 日1、实验目的1)掌握Linux环境下的C/C++编程方法2)加深对进程概念的理解，明确进程和程序的区别。
3)进一步认识进程并发执行的实质。
2、实验内容1)编写一段程序fc1.c，使用系统调用fork( )创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。
试观察记录屏幕上的显示结果，并分析原因。
2)编写一段程序fc2.c，使用系统调用fork( )创建一个子进程，该子进程再创建一个子进程，三者都各自以1秒为间隔循环打印各自的PID和其父进程的PID。
3)编写一段程序fc3.c，父进程A使用系统调用fork( ) 创建一个子进程B，该子进程再创建一个子进程C，每个进程一开始都打印各自的PID和其父进程的PID。
其中，A和B各自调用wait函数等待它们的子进程结束，C休眠10秒后结束。
3、实验笔记记录在完成该次实验作业的过程中，每次上机实验的时间和简要的实验过程，每次的实验过程应包括：该次上机完成的实验内容，编程思路，调试程序中遇到的问题，解决方法，遗留的问题等。
4、总结对本次实践进行简单总结（例如，问题，收获等）。
附录A：程序源代码：1)第1个程序#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/types.h>int main(){pid_t pid,pr;pid=fork();if(pid<0) printf(“error!”);else if(pid==0) printf(“child,b”);else {printf(“father,a”);pr=fork();if(pr==0) printf(“otherchild,c”);}return 0;}2)第2个程序#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/types.h>int main(){pid_t pid,pr;pid=fork();if(pid<0) printf(“error!”);else if(pid==0){while（1）{printf(“my pid is %d”,getpid());printf(“my parent’s pid is %d”,getppid());sleep(1);}pr=fork();{if(pr==0)while（1）{printf(“my pid is %d”,getpid());printf(“my parent’s pid is %d”,getppid();sleep(1);}}}else {while（1）{printf(“my pid is %d”,getpid());printf(“my parent’s pid is %d”,getppid());sleep(1);}}return 0;}3)第3个程序#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>int main(){pid_t pid,pidd,pa,pb;pid=fork();if(pid==0){printf(“my pid is %d”,getpid());printf(“my parent’s pid is %d”,getppid());pb=wait(NULL);pidd=fork();{printf(“my pid is %d”,getpid());printf(“my parent’s pid is %d”,getppid());if(pidd==0)sleep(10);}}else { printf(“my pid is %d”,getpid());printf(“my parent’s pid is %d”,getppid());pa=wait(NULL);}return 0 ;}。
操作系统实验报告实验二
操作系统实验报告实验二一、实验目的本次操作系统实验二的目的在于深入理解和掌握操作系统中的进程管理和进程调度相关知识，通过实际的编程和实验操作，观察和分析不同进程调度算法的性能和效果，提高对操作系统核心概念的理解和应用能力。
二、实验环境本次实验在 Windows 10 操作系统下进行，使用 Visual Studio 2019作为编程工具。
实验中涉及的编程语言为 C+＋。
三、实验内容（一）进程创建与控制编写程序实现创建多个进程，并通过进程控制原语（如创建、等待、终止等）对进程进行管理和控制。
（二）进程调度算法实现1、先来先服务（FCFS）调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源进行执行。
2、短作业优先（SJF）调度算法优先调度执行时间短的进程，以减少平均等待时间。
3、时间片轮转（RR）调度算法将 CPU 时间划分为固定大小的时间片，每个进程在一个时间片内执行，时间片结束后切换到下一个进程。
（三）性能评估指标1、平均等待时间所有进程等待时间的总和除以进程数量。
2、平均周转时间所有进程周转时间的总和除以进程数量。
周转时间为进程从提交到完成的时间间隔。
四、实验步骤（一）进程创建与控制1、定义进程结构体，包含进程 ID、到达时间、执行时间等信息。
2、使用系统调用或库函数创建进程。
3、在父进程中通过等待函数等待子进程结束，并获取子进程的返回状态。
（二）进程调度算法实现1、先来先服务（FCFS）调度算法按照进程到达时间的先后顺序将进程放入就绪队列。
从就绪队列中取出第一个进程进行调度执行。
2、短作业优先（SJF）调度算法计算每个进程的执行时间。
按照执行时间从小到大的顺序将进程放入就绪队列。
从就绪队列中取出执行时间最短的进程进行调度执行。
3、时间片轮转（RR）调度算法将进程按照到达时间先后顺序放入就绪队列。
为每个进程分配一个时间片，当时间片用完后，将进程放入就绪队列尾部，重新调度下一个进程。
《操作系统》上机实验一报告
《操作系统》上机实验一报告目录一、实验关键问题二、代码设计思路三、实现的关键代码四、程序运行结果五、实验总结一、实验关键问题1.1要求：编写一个Linux系统C程序，由父亲创建2个子进程，再由子进程各自从控制台接收一串字符串，保存在各自的全局字符串变量中，然后正常结束。
父进程调用waitpid等待子进程结束，并分别显示每个子进程的进程标识号和所接收的字符串。
1.2要求：父进程创建一子进程，父进程向子进程发送数据，子进程接收数据，并写入文件。
二、代码设计思路2.1 问题1.1的代码设计思路由父进程创建两个共享内存→分别创建两个子进程→提示用户输入信息，并将信息存到子进程各自对应的共享内存中→等待子进程结束→子进程结束后，父进程被唤醒并与共享内存连接→分别从这两个内存共享中获取数据，并把数据和对应的子进程PID输出到屏幕上→父进程结束2.2问题1.2的代码设计思路由父进程创建管道→创建子进程→父进程关闭读管道，获取用户输入的数据→把数据写入写管道中，关闭写管道→等待子进程结束，此时父进程挂起→子进程关闭写管道→子进程读取父进程放入读管道中的数据，显示数据到屏幕上→将数据写入文件“CP_file.txt”中→关闭读管道，关闭文件→结束子进程→父进程被唤醒后父进程也结束。
三、实现的关键代码3.1 问题1.1的实现代码#include <unistd.h>#include <sys/ipc.h>#include <sys/shm.h>#include <sys/types.h>#include <sys/wait.h>#include <stdio.h>#include <stdlib.h>#define Key0 9876#define Key1 5432#define Size 2048 //Size表示共享内存大小，此处设置为2048int main(){int shmid1, shmid2;//共享内存的标识符//父进程创建共享内存shmid1和shmid2shmid1 = shmget(Key0, Size, IPC_CREAT|0600);shmid2 = shmget(Key1, Size, IPC_CREAT|0600);pid_t pid1, pid2;//子进程标识符char *shmaddr;//连接地址//父进程创建子进程pid1if ((pid1 = fork()) == 0){shmaddr = (char*)shmat(shmid1, NULL, 0);/*shmat（）实现子进程pid1与共享内存shmid1的连接*/printf("Child process 1 is running now, enter a string:");/*请求用户输入一个字符串*/fgets(shmaddr, Size-1, stdin);/*fgets（）将信息存到shmaddr所指的内存空间*/shmdt(shmaddr);/*shmdt（）使该进程脱离该共享内存断，但并不删除该内存段*/return 0;}printf("\nWaitting for child process 1...\n");waitpid(pid1, NULL, 0);//等待子进程pid1结束printf("Child process 1 is over...\n");//父进程创建子进程pid2if ((pid2 = fork()) == 0){shmaddr = (char*)shmat(shmid2, NULL, 0);printf("Child process 2 is running now, enter a string:");fgets(shmaddr, Size-1, stdin);shmdt(shmaddr);return 0;}printf("\nWaitting for chils process 2...\n");waitpid(pid2, NULL, 0);printf("Child process 2 is over...\n\n");shmaddr = (char*)shmat(shmid1, NULL, 0); /*父进程与共享内存shmid1连接*/printf("Child process 1: PID=%d message: %s\n", pid1, shmaddr);/*屏幕显示共享内存shmid1的信息*/shmdt(shmaddr);shmctl(shmid1, IPC_RMID, NULL);//删除共享内存shmid1shmaddr = (char*)shmat(shmid2, NULL, 0);printf("Child process 2: PID=%d message: %s\n", pid2, shmaddr);shmdt(shmaddr);shmctl(shmid2, IPC_RMID, NULL);return 0;}3.2 问题1.2的实现代码#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#define maxsize 2048//maxsize表示传送的最大数据量，此处设置为2048 int main(){pid_t pid;//子进程标识符int pip[2];//管道描述符//创建管道if (pipe(pip) < 0)//管道创建失败{printf("Faile to create pipe!\n");return -1;}//创建子进程if ((pid = fork()) < 0)//子进程创建失败{printf("Faile to create child process!\n");return -1;}char buffer[maxsize];// 数据缓冲区FILE *file;// 文件描述符//子进程执行if ( pid==0 ){close(pip[1]);// 关闭写管道read(pip[0], buffer, maxsize);// 读取父进程发送的管道数据close(pip[0]);// 关闭读管道//屏幕输出子进程接收到得信息printf("Child process is running now, the received record:\n%s", buffer);if ((file=fopen("CP_file.txt", "w"))==NULL)/*打开CP_file.txt文件失败*/{printf("Error!Can't open CP_file.txt.\n");exit(1);}else{fputs(buffer, file);// 成功打开CP_file.txt文件，将数据写入文件中fclose(file);// 关闭文件return 0;}}//父进程执行else{close(pip[0]);// 关闭读管道printf("Parent process is running now, enter the record:\n");fgets(buffer, maxsize-1, stdin);// 接收用户输入的数据write(pip[1], buffer, maxsize);// 接收用户输入的数据close(pip[1]);// 关闭写管道waitpid(pid, NULL, 0);// 父进程等待子进程结束return 0;}}四、程序运行结果4.1 问题1.1的程序运行结果（图4.1所示）（图4.1）4.2 问题1.2的程序运行结果（图4.2所示）（图4.2）五、实验总结通过本次上机实验，我的收获很多。
计算机操作系统实训教程之进程的创建实验报告
计算机操作系统实训教程实验报告姓名王学杰专业计算机应用技术班级班课程操作系统实验项目进程的创建【实验目的】.加深对进程、进程树等概念的理解。
.进一步明确进程和程序的区别。
.理解进程并发执行的实质。
.掌握系统中进程的创建方法及并发执行的情况。
【实验内容】.编写一段程序，使用系统调用（）创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一段字符信息。
.学习对后台执行程序的控制方式。
.分析程序执行过程中产生的子进程情况。
【实验步骤】一、、编写源代码生成源文件“$ ”。
.编译“$ –”。
.前台运行“$ ”（按组合键终止死循环的程序）。
.多次使用–命令查看进程状态。
.使用命令控制该进程。
二、编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
.后台运行“$ ”。
.查看进程树“$ ”。
三例编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
.运行“$ ”。
四编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
.运行“$”。
五编写源代码生成源文件“”。
.编译源文件生成可执行程序“”：“$ –”。
运行结果如下【实验总结】一、入门知识一个进程，包括代码、数据和分配给进程的资源。
（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。
一个进程调用（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。
然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。
相当于克隆了一个自己。
调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：）在父进程中，返回新创建子进程的进程；）在子进程中，返回；）如果出现错误，返回一个负值；二、（）与（）区别（）与（）都是创建一个进程，那他们有什么区别呢？总结有以下三点区别：. （）：子进程拷贝父进程的数据段，堆栈段（）：子进程与父进程共享数据段. （）父子进程的执行次序不确定保证子进程先运行，在调用或之前与父进程数据是共享的,在它调用或之后父进程才可能被调度运行。
《操作系统》系统进程实验报告
《操作系统》系统进程实验报告
hongdingjin
实验一（写出最常见和感兴趣的10个）
1、explorer.exe
Windows资源管理器，它用于管理图形用户界面，包括开始菜单、任务栏、桌面和文件。
2、Svchost.exe
Windows操作系统进程，加载并执行系统服务指定的动态链接库文件。
3、smss.exe
Windows操作系统进程，调用对话管理子系统和负责操作系统对话。
4、lsass.exe
Windows操作系统的本地安全权限服务，控制Windows系统的安全机制。
5、sqlswevr.exe
Microsoft SQL Server服务套装的一部分，用于支持微软SQL基础服务。
6、mysqld.exe
Mysql中Windows mysql server数据库服务器相关程序，用于加载该系统相关数据库服务组件。
7、SPOOLSV.exe
将文件加载到内存中以便迟后打印。
8、Winlogon.exe
管理用户登录。
9、ismserv.exe
允许在 Windows Advanced Server 站点间发送和接收消息。
10、smlogsvc.exe
配置性能日志和警报。
实验二（自己下载Process Viewer等查看进程软件，查看某进程的进程树。
）
Process Viewer程序界面
查看360SE.exe的进程树
实验三（自己在网络搜索并下载进程分析软件，看是否有可疑进程。
）360安全卫士进程管理器是一个不错的查看进程分析软件。
经查，没有发现可疑进程。
操作系统实验报告(包括线程,进程,文件系统管理,linux+shell简单命令)
操作系统实验报告班级：030613学号：03061331姓名：裴帅帅实验一：进程的建立一、实验内容创建进程及子进程，在父子进程间实现进程通信，创建进程并显示标识等进程控制块的属性信息，显示父子进程的通信信息和相应的应答信息。
使用匿名管道实现父子进程之间的通信。
二、源程序1、创建匿名管道SECURITY_ATTRIBUTES sa;sa.bInheritHandle=true;sa.lpSecurityDescriptor=NULL;sa.nLength=sizeof(SECURITY_ATTRIBUTES);if(!CreatePipe(&m_hRead,&m_hWrite,&sa,0)){MessageBox("创建匿名管道失败");return false;}2、创建子进程STARTUPINFO si;ZeroMemory(&si,sizeof(STARTUPINFO));si.cb=sizeof(STARTUPINFO);si.dwFlags=STARTF_USESTDHANDLES;si.hStdInput=m_hRead;si.hStdOutput=m_hWrite;si.hStdError=GetStdHandle(STD_ERROR_HANDLE);if(!CreateProcess(NULL,"子进.exe",NULL,NULL,true,0,NULL,NULL,&si,&pi)) {MessageBox("创建子进程失败");CloseHandle(m_hRead);CloseHandle(m_hWrite);m_hRead=NULL;m_hWrite=NULL;return;}3、销毁子进程if(m_hRead)CloseHandle(m_hRead);if(m_hWrite)CloseHandle(m_hWrite);TerminateProcess(pi.hProcess ,0);4、向匿名管道中写信息即发送信息DWORD deWrite;CString sendData;m_s.GetWindowText(sendData);int length;length=sendData.GetLength ();char *buffer=new char[length+1];for(int i=0;i<length;i++){buffer[i]=sendData[i];}buffer[length]='\0';if(!WriteFile(m_hWrite,buffer,length,&deWrite,NULL)){MessageBox("发送数据失败");}delete buffer;5、从匿名管道中读取信息即接收信息char buff[100];DWORD deRead;if(!ReadFile(m_hRead,buff,100,&deRead,NULL)){MessageBox("读取数据失败");}CString receiveData;for(int i=0;i<=(int)deRead;i++){receiveData+=buff[i];}receiveData+='\0';m_r.SetWindowText (receiveData);三、实验结果实验结果实现了父进程向匿名管道中写信息，然后在子进程端可以从匿名管道中读取该信息；也可以子进程向管道中写入信息，然后父进程从中读取后显示。
操作系统上机实验报告
操作系统上机实验报告计算机科学与技术学院操作系统上机实验报告实验名称：进程和线程实验⽬的：理解unix/Linux下进程和线程的创建、并发执⾏过程。
实验内容：1．进程的创建2．多线程应⽤实验步骤：⼀、进程的创建下⾯这个C程序展⽰了UNIX系统中⽗进程创建⼦进程及各⾃分开活动的情况。
1、实验指导fork( )创建⼀个新进程。
系统调⽤格式：pid=fork( )参数定义：int fork( )fork( )返回值意义如下：0：在⼦进程中，pid变量保存的fork( )返回值为0，表⽰当前进程是⼦进程。
>0：在⽗进程中，pid变量保存的fork( )返回值为⼦进程的id值（进程唯⼀标识符）。
-1：创建失败。
如果fork( )调⽤成功，它向⽗进程返回⼦进程的PID，并向⼦进程返回0，即fork( )被调⽤了⼀次，但返回了两次。
此时OS在内存中建⽴⼀个新进程，所建的新进程是调⽤fork( )⽗进程（parent process）的副本，称为⼦进程（child process）。
⼦进程继承了⽗进程的许多特性，并具有与⽗进程完全相同的⽤户级上下⽂。
⽗进程与⼦进程并发执⾏。
2、参考程序代码/*process.c*/#include#includemain(int argc,char *argv[]){int pid;/* fork another process */pid = fork();if (pid < 0) { /* error occurred */fprintf(stderr, "Fork Failed");exit(-1);}else if (pid == 0) { /* child process */ execlp( "/bin/ls", "ls",NULL);}else {/* parent process *//* parent will wait for the child to complete */ wait(NULL);printf( "Child Complete" );exit(0);}}3、编译和运⾏$gcc process.c –o processs4、运⾏$./process5、思考（1）系统是怎样创建进程的？⽤fork（）系统调⽤创建。
操作系统进程实验
实验一、进程管理(3学时、必做)一、实验目的通过实验使学生进一步了解进程、进程状态、进程控制等基本概念。
基本能达到下列具体的目标：1、理解进程 PCB 的概念，以及 PCB 如何实现、如何组织以及管理。
2、复习数据结构中如何对链的操作，包括建链、删除、插入结点等，来实现进程的管理。
二、实验内容1、建立一个结点，即 PCB 块包括用户标识域、状态域（执行、等待、就绪）、 link 域。
2、建立三个队列（执行队列、就绪队列、等待队列）。
3、根据进程状态转换实现对三个队列的具体操作。
具体的驱动可以采用时间片算法或手动调度的形式完成三个状态之间的转换4、用 switch 选择语句选择状态。
5、按照自己的设定能完成所有的状态转换的运行（包括创建和运行结束）。
三、实验步骤1、复习进程管理三状态模型部分内容。
2、预习C++Builder或VC++、Delphi、JBuilder线程编程。
3、运行示例程序，进一步明确实验要求。
可以采用控制台模式或窗口模式。
4、上机编程、调试程序。
5、完成实验报告。
实验1的附加资料1、控制台模式进程管理的使用说明图1. 输入结束字符本程序是输入一个字符串，每个作为一个进程的名称，以指定的字符为结束字符，比较容易实现，其实可以在程序运行期间任意创建进程才是最好的。
图2. 输入进程名称一次性的创建了多个进程，进入三状态模型，按照要求进行状态之间的转移，只要输入1、2、3、4、5数字，按回车即可。
图3. 进程管理程序的主界面2、窗口模式的进程管理图4. 简单进程管理的主界面创建进程进入就绪队列，其排序可以按照FIFO的形式，也可以按照优先级的形式，为此需要在PCB节点中增加优先级数。
进程状态的转化在三个队列之间实现，输入进程的名称，选择合适的功能按钮。
如果不符合状态转换的规则，则弹出错误的对话框，说明原因。
3、基于时间片调度的进程管理图5. 基于时间片的进程管理主界面创建一个进程，给出工作量，每个进程所占的时间片大小为20个单位，实现就绪状态到执行状态之间的转化。
操作系统实验2 进程创建
实验二进程的创建一、实验目的1.加深对进程概念的理解，明确进程和程序的区别。
2.掌握进程的创建方法二、实验学时2学时三、实验内容1.ps命令的使用（请将使用的命令和结果写在实验报告册中）（1）显示所有进程，找出使用当前进程的进程ID号，查看其状态。
（2）列出目前所有面向用户的进程。
（进程内可省略）（3）显示所有自己所在用户的进程，并以长格式输出。
（4）用面向任务的格式显示个人用户中bash命令中的所有实例；并查看其父进程的详细信息。
2.at进程调度（1）设置一个调度，要求在2018年1月1日0时，想所有用户发送新年问候[操作步骤]（1）按组合键[Ctrl+Alt+F1]切换到第一个虚拟终端，以用户名aaa登录；按组合键[Ctrl+Alt+F2]切换到第二个虚拟终端，以超级用户身份登录字符界面，以下操作在该终端上完成；（2）输入命令“at 00:00 01012018”，设置2018年1月1日0时执行的at调度；（3）屏幕出现at调度的命令提示符“at >”，在提示符后输入“wall Happy New Year!”，向用户发送问候语；（4）在提示符后输入[Ctrl+D]结束at调度内容的输入，屏幕将根据设置显示作业号和将要运行的时间。
（请给出截图或写在实验报告册中）可调整系统时间为2017年12月31日23时59分(输入命令“date 123123592017”)，稍等后观察at调度的执行效果，再切换到第一个虚拟终端观察at调度的执行效果；之后请切换到超级用户终端恢复系统时间为正确的时间。
（请给at调度的执行结果截图或写在实验报告册中）3.进程的创建（1）编写一段程序，使用系统调用fork（）创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。
参考程序<程序2.1>#include <stdio.h>main( )int p1,p2;while((p1=fork( ))= = -1); /*创建子进程p1*/if (p1= =0) putchar('b');else{while((p2=fork( ))= = -1); /*创建子进程p2*/if(p2= =0) putchar('c');else putchar('a');}}分析并运行该程序回答如下问题，将结果与分析写在实验报告中。
计算机操作系统上机实验报告
计算机操作系统上机实验报告Pcb结构体typedef struct{int ID; //进程标记号int Priority; //进程优先级int Intime; //进程进入CPU时间int Alltime; //进程运行总时间int usetime; //进程使用时间}PCB;//定义队列typedef struct QNode{PCB data;struct QNode *next;}QNode;typedef struct{QNode *front,*rear;int Length;}LinkQueue;创建队列void CreateQueue(LinkQueue &Q){…}进入队列到表尾void INQueue(LinkQueue &Q,PCB one){…}进入队列到表头void TOUQueue(LinkQueue &Q,PCB one){…}出队列PCB OUTQueue(LinkQueue &Q){…}主要实现步骤：1、小组成员共同就实验要求进行讨论，弄清进程管理的基本思想和流程，制定出具体的进度计划并分配了相关的任务。
2、小组成员各自根据要求完成任务，在此过程中任务会根据新的要求有所变化，各结构及函数等都会有相应的变化，此步骤也是完善的过程。
3、代码完成进行程序测试。
发现程序的BUG后改进程序。
4、完成实验报告的填写制作PPT。
本实验涉及的主要算法细节说明（包括数据结构）//PCB结构体typedef struct{int ID; //进程标记号int Priority; //进程优先级int Intime; //进程进入CPU时间int Alltime; //进程运行总时间int usetime; //进程使用时间}PCB;//定义队列typedef struct QNode{PCB data;struct QNode *next;}QNode;typedef struct{QNode *front,*rear;int Length;}LinkQueue;//创建队列void CreateQueue(LinkQueue &Q){Q.front=Q.rear=(QNode *)malloc(sizeof(QNode));Q.Length=0;if(!Q.front)MessageBox("分配内失败");}本实验涉及的主要算法细节说明（包括数据结构）//进入队列到表尾void INQueue(LinkQueue &Q,PCB one){QNode *p=(QNode *)malloc(sizeof(QNode)); if(!p)MessageBox("分配内失败");Q.rear->data=one;Q.rear->next=p;Q.rear=p;p->next=NULL;Q.Length++;}//进入队列到表头void TOUQueue(LinkQueue &Q,PCB one){ QNode *p=(QNode *)malloc(sizeof(QNode));if(!p)MessageBox("分配内失败");p->data=one;p->next=Q.front;Q.front=p;Q.Length++;}添加进程：时间片算法：5: 1进程进入就绪队列，进入执行队列。
操作系统第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()挂起进程的时间太短，导致进程树⽆法打印，增加挂起进程的时间即可。
操作系统实验二(进程管理)
操作系统进程管理实验实验题目：（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 <stdio.h>int main(int argc, char *argv[]){int pid1,pid2; /*fork first child process*/if ( ( pid1=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid1=fork() ) == 0 ){printf( "b\n" );}/*fork second child process*/if ( ( pid2=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid2=fork() ) == 0 ){printf( "c\n" );}/*parent process*/else{wait(NULL);printf( "a\n" );exit(0);}return 0;}（2）、进程的控制#include <stdio.h>int main(int argc, char *argv[]){ int pid1,pid2;/*fork first child process*/if ( ( pid1=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid1=fork() ) == 0 ){printf( "This is my Unix OS program!\n" );}/*fork second child process*/if ( ( pid2=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid2=fork() ) == 0 ){printf( "This is the second Child process!\n" );}/*parent process*/else{wait(NULL);printf( "This is the Parent process\n" );exit(0);}return 0;}（3）编制一段程序，使其实现进程的软中断通信。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二Linux 进程实验
姓名：段叶叶班级：信息1302 学号：07131052
地点：东区实验室FF109
时间：2014年10月13日星期一
成绩：
一、实验内容
1.创建进程的系统调用fork（）；
2.创建进程的系统调用vfork（）；
3.执行新程序的系统调用exec（）；
4.等待进程结束的系统调用wait（）或waitpid（）。
前三题必做，最后一题选做。
二、实验目的
熟悉进程的系统调用。
三、实验环境
登陆Linux虚拟机，进入Linux shell，提示符为$，表示普通用户提示符。
四、实验题目
1. 【题目】：编写程序forkgrandchild.c，用来创建孙子进程。
【要求】：在读懂程序forktest.c的基础上，编写程序
forkgrandchild.c(forkgrandchild.c创建在用户名（如wm）目录下的process 目录下)，所创建的程序forkgrandchild.c可实现创建孙子进程，并显示孙子进程的pid，其父进程的pid，forkgrandchild.c要求可读性好，用户界面友好。
【预备知识】：
1)Linux进程状态
●运行状态：程序正在运行或在运行队列中等待运行。
●可中断等待状态：进程正在等待某个事件完成，等待过程可被信号或定时器
唤醒。
●不可中断等待状态：进程正在等待某个事件完成，不可被信号或定时器唤醒，
必须等待事件的发生，才可唤醒。
●僵死状态：进程已终止，但进程描述符依然存在，直到父进程调动wait()函
数后释放。
●停止状态：进程因收到SIGSTOP SIGSTP SIGTIN SIGTOU信号后停止运行
或该进程正在被跟踪（调式程序时）。
2)ps命令
●ps命令可查看进程的当前状态。
●如ps aux（相关命令参数自学）
●对ps命令结果字符的解释
<（高优先级进程）、N（低优先级进程）、L（内存锁页，即页不可被换出内存）、s（该进程为会话首进程）、l（多线程进程）、+（进程位于前台进程组）、R（运行状态）、Z（僵死状态）、D（不可中断等待状态）、S（可中断等待状态）、T（停止状态）。
3)fork（）函数
fork（）是创建一个新进程的唯一方法，子进程可以继承其父进程几乎所有的资源。
在命令行下使用man 2 fork 可获得该函数的函数声明。
fork（）有两个返回值。
成功调用fork后，当前进程实际上已经分裂为两个进程，一个是原来的父进程，另一个是刚刚创建的子进程。
父子进程在调用fork地方分开，一个是父进程调用fork的返回值，返回值为刚刚创建的子进程的pid；另一个是子进程中fork函数的返回值，为0。
fork返回两次的前提是进程创建成功，若失败返回为-1。
用返回值可区分父子进程。
fork之后是父还是子进程先运行是不确定的，这取决于内核所使用的调度算法，一般是交替执行，使进程享有同等执行权。
forktest.c 源代码
【问题】：
1)解释stdio.h、unistd.h、sys/types.h头文件的作用？
2)getpid()、getppid()、fork()的功能是什么？
3)写出forkgrandchild.c的源代码。
2. 【题目】：diffork.c 的创建
【要求】：
上机实现下面diffork.c 的运行，体会fork （）和vfork （）的区别。
【预备知识】：
1) fork （）和vfork （）的区别
● fork （）和vfork （）都是调用一次，返回值两次。
● fork （）创建一子进程时，子进程只是完全复制父进程资源，这样得到的子
进程独立于父进程，具有良好的并发性，但开销较大，有时是不需要的，比如fork 一个进程后，立即调用exec 执行另一个应用程序，那么fork 过程中子进程对父进程地址空间的复制将是一个多余的过程，而vfork
（）创建的
子进程共享父进程的地址空间，不拷贝父进程的地址空间，这大大减少了系统开销。
vfork（）保证子进程先运行，当它调用exec（）或exit之后，父进程才可能被调度。
【注意】：
将diffork.c中的sleep（）的参数增大些，开启另一个终端，在该终端下输入ps aux查看父子进程的信息，特别是状态信息。
【结果】：
3. 【题目】：执行新程序的系统调用exec（）
【要求】：
上机实现下面processimage.c和execve.c的运行，体会执行新程序的系统调用。
【预备知识】：
1)使用fork或vfork创建子进程后，子进程通常会调用exec函数来执行另
外一个程序，系统调用exec用于执行一个可执行程序以代替当前进程的
执行映像。
2)exec调用并没有生成新进程，一个进程一旦调用exec函数，它本身就死
亡了。
系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈
段，并为新进程分配新的数据段和堆栈段，唯一保留是pid，即，对系统
而言，还是同一个进程，不过执行的已经是另一个程序了。
3)exec函数族有6种不同的调用形似，如execv（）、execve（）等，它们
声明在unistd.h中。
【注意】：
1)理解带参数的main（）函数。
2)在Linux命令行下，使用man execve 获取该函数的帮助。
【问题】：先编译链接processimage.c，再编译链接execve.c，查看运行结果，结果说明了什么？
运行结果截图见下页
4. 【题目】：等待进程结束的系统调用wait（）或waitpid（）。
【要求】：
上机实现下面wait.c的运行，体会等待进程结束wait（）系统调用。
【预备知识】：
子进程先于父进程终止，而父进程又没有调用wait函数等待子进程结束，子进程进入僵死状态，并会一直保持下去除非重启。
子进程进入僵死状态时，内核只保存该进程的一些必要信息以备父进程所需。
此时子进程始终占用着资源，同时也减少了系统可创建的最大进程数。
如果子进程先于父进程终止，且父进程调用了wait或waitpid函数，则父进程会等待子进程结束，就不会使子进程变为僵尸进程。
【注意】：
1)在Linux命令行下，使用man命令获取wait和waitpid函数的帮助。
2)父进程调用wait后被挂起等待（此时打开另一个终端，输入ps aux 命令
可查看父进程的状态），直到子进程结束。
子进程正常结束后，wait函数
返回刚刚结束运行的子进程的pid，宏WEXITSTATUS获取子进程的退出
码。
【问题】：编译链接wait.c，并运行wait，结果说明了什么？。