进程控制实验报告

实验名称: 进程管理实验要求:阅读后面的C语言实例，修改程序，使其优先数在运行期间可以变化(动态优先数)。

例如，当某进程被时间片中断次数增加到一定数目时，提高其优先权。

关键问题:读懂源程序代码，了解进程管理的方式，并设计一个算法使程序能在运行过程中修改进程优先级。

设计思路:在进程控制块中定义一个记录进程中断次数的变量，在block函数中设置跟踪并记录进程中断次数，在调度函数schedule中设置算法，在进程中断3次后将该进程的优先级提升至最高。

改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态，'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针，指示在同一信号量上等待的下一个等待进程的进程号。

int priority; //进程优先数，值越小，优先级越高。

int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量；seed为随机值；registeri模拟寄存器值,存放计算的重复次数。

int registeri,s1,s2,seed,exe=NIL;//exe为当前运行（占有cpu）的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。

//对应信号量sem[0]、sem[1]分别有两个阻塞队列，队列首由sem[].firstwr指定，队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区，其中savearea[][0]为寄存器内容，savearea[][1]为下一条指令地址。

一、实验目的本次实验旨在通过Linux操作系统的实践操作，加深对进程控制概念的理解。

通过学习进程的创建、调度、同步、通信等基本操作，掌握进程控制的基本方法，并了解进程间通信的机制。

二、实验环境1. 硬件环境：Intel(R) Core(TM) i5-3210M CPU2.50GHz，4.00GB内存。

2. 软件环境：64位Linux操作系统。

三、实验内容1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程间通信四、实验步骤1. 进程的创建与终止（1）使用`fork()`函数创建子进程，通过比较返回值判断创建是否成功。

```cpid_t pid = fork();if (pid < 0) {perror("fork failed");exit(1);}```（2）使用`exit()`函数终止进程。

```cexit(0);```2. 进程的调度与优先级（1）使用`nice()`函数调整进程优先级。

```cnice(10); // 降低进程优先级```（2）使用`priority_seta()`函数设置进程优先级。

```cstruct sched_param param;param.sched_priority = 10;if (sched_setscheduler(pid, SCHED_RR, &param) == -1) { perror("sched_setscheduler failed");exit(1);}```3. 进程同步与互斥（1）使用`semaphore_t`类型的信号量实现进程同步。

```csemaphore_t sem;sem_init(&sem, 0, 1);sem_wait(&sem);// 执行临界区代码sem_post(&sem);sem_destroy(&sem);```（2）使用`mutex_t`类型的互斥锁实现进程互斥。

测试过程: （实验中出现的问题、错误、解决方法）创建好项目和文件, 对文件进行编译和运行, 编译没有错误, 但是运行总是提示有2个错误。

解决办法：在新建项目的时候“新建”, 然后新建文件, 程序就可以正常的运行了。

实验总结:1、课下没有对Microsoft Visual c++ 6.0进行深入的研究, 还是好多问题不知道怎么解决, 好好钻研一下这个很有必要的啊!评语与成绩:教师签名:年月日实验名称进程控制实验类型验证性实验时间实验环境Windows xp 、Microsoft Visual c++ 6.0实验目的与要求:1．通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作, 进一步熟悉操作系统的进程概念, 理解Windows 2000进程的“一生”。

2.通过阅读和分析实验程序，学习创建进程、观察进程和终止进程的程序设计方法。

实验内容:本实验给出了三段程序：创建进程、正在运行的进程和终止进程, 阅读程序回答所提问题, 分析运行结果。

一、实验步骤: （算法描述、源程序、操作步骤和方法）二、创建进程回答问题:1.该程序是一个简单使用CreateProcess（）API函数的例子。

首先形成简单的命令行, 提供当前EXE文件的指定文件名和代表生成克隆进程的号码。

大多数参数都可取默认值, 但是创建标志参数使用了CREATE_NEW_CONSOLE标志, 指示新进程分配自己的控制台, 这使得运行程序时, 在任务栏上产生许多活动标记。

然后该克隆进程的创建方法关闭传递过来的句柄并返回main （）函数。

在关闭程序之前, 每一进程的执行主线程暂停一下, 以便让用户看到其中的至少一个窗口。

2、CreateProcess（）函数有几个核心参数？本实验程序中设置的各个参数的值是什么？答、CreateProcess（）函数有10个核心参数参数的值为: CreateProcess(szFilename, //产生这个EXE的应用程序的名称szCmdLine, //告诉其行为像一个子进程的标志NULL, //缺省的进程安全性NULL, //缺省的线程安全性FALSE, //不继承句柄CREATE_NEW_CONSOLE, //使用新的控制台NULL, //新的环境NULL, //当前目录&si, //启动信息&pi);3.程序运行时屏幕显示的信息是什么？答、三、运行进程1、回答问题:2、给出运行结果（当前PID信息、操作系统版本、系统提示信息）答、运行结果为:2.如何获得当前的PID和操作系统版本可利用GetCurrentProcessId()API函数查看系统当前进程的标识符（pid）, 该pid在整个系统中都可使用。

进程控制实验报告进程控制实验报告引言：进程控制是操作系统中的重要概念之一，它负责管理和调度计算机系统中的各个进程，确保它们能够按照一定的顺序和优先级进行执行。

本实验旨在通过编写一个简单的进程控制程序，加深对进程控制的理解，并探索其在实际应用中的作用。

实验目的：1. 理解进程控制的基本概念和原理；2. 掌握进程创建、终止和切换的方法；3. 熟悉进程调度算法的实现；4. 分析进程控制在实际应用中的意义和效果。

实验过程：本次实验中，我们选择使用C语言编写一个简单的进程控制程序，通过创建多个进程并进行调度，观察它们的执行顺序和状态变化。

首先，我们定义了一个进程结构体，包含进程ID、进程状态和进程优先级等信息。

然后，我们编写了创建进程的函数，通过调用系统调用接口fork()来创建新的进程，并为其分配唯一的进程ID。

在进程创建完成后，我们实现了一个简单的进程调度算法，根据进程的优先级和状态来决定下一个要执行的进程。

我们使用了优先级队列来管理进程，将优先级高的进程排在队列的前面，以确保它们能够优先执行。

接下来，我们模拟了进程的运行过程，通过设置进程的状态和优先级，来模拟进程的创建、终止和切换。

我们观察到，当一个进程被创建时，它会被添加到就绪队列中，等待系统调度执行。

当一个进程的时间片用完或者发生阻塞时，它会被暂停并切换到下一个就绪进程执行。

实验结果：通过多次运行实验程序，我们观察到进程的创建、终止和切换过程。

我们发现，进程的创建是一个相对较慢的过程，而进程的切换则非常迅速。

这是因为进程的创建需要为其分配资源和初始化环境，而进程的切换只需要保存和恢复进程的状态即可。

我们还发现，进程的优先级对于进程的执行顺序有重要影响。

当一个进程的优先级较高时，它会被优先执行，而其他进程则需要等待。

这使得系统能够根据进程的重要性和紧急程度来进行合理的调度，提高系统的效率和响应速度。

讨论与总结：进程控制是操作系统中非常重要的一部分，它负责管理和调度计算机系统中的各个进程。

实验内容
1、用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容
2、利用wait( )来控制进程执行顺序
实验数据
vi编写的程序
程序运行结果
实验总结
进程切换时将涉及到有关资源指针的保存以及地址空间的变化等问题；线程切换时，由于统一进程内的线程共享资源和地址空间将不涉及资源信息的保存和( )联合使用能为程序开发提供有力支持。用fork( )建立子进程，然后在子进程中使用exec( )，这样就实现了父进程与一个与它完全不同子进程的并发执行。
一般，wait、exec联合使用的模型为：
int status;
............
if (fork( )= =0)
{
...........;
execl(...);
...........;
}
wait(&status);
3、wait（）
等待子进程运行结束。如果子进程没有完成，父进程一直等待。wait( )将调用进程挂起，直至其子进程因暂停或终止而发来软中断信号为止。如果在wait( )前已有子进程暂停或终止，则调用进程做适当处理后便返回。
1、exec( )系列
系统调用exec( )系列，也可用于新程序的运行。fork( )只是将父进程的用户级上下文拷贝到新进程中，而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。exec( )系列中的系统调用都完成相同的功能，它们把一个新程序装入内存，来改变调用进程的执行代码，从而形成新进程。如果exec( )调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id与调用进程相同。2、exec( )和fork( )联合使用

★进程管理实验报告_共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族调用可以执行给定程序。

第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. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。

操作系统进程控制实验报告操作系统进程控制实验报告硬件环境：处理器：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.信号的机理：信号是用来通知进程某个特定的事件已经发生。

信号是由特定的事件产生，信号必须要发送到进程，一旦发送，进程必须得到处理。

信号可以可以有系统默认处理也可以用户自定义处理。

进程控制与进程通信程序实验报告一、引言进程是计算机系统中最基本的概念之一，是操作系统中最小的资源管理单位。

进程控制与进程通信是操作系统中重要的内容，涉及到进程的创建、调度和终止，以及进程间的信息传递和同步管理。

本实验旨在通过编写进程控制与进程通信程序，加深对操作系统中进程管理和通信机制的理解。

二、实验目的1. 理解进程的概念和特点，掌握进程的创建、调度和终止方法。

2. 掌握进程通信的基本原理和方法，包括共享内存、管道、消息队列和信号量等。

3. 能够编写简单的进程控制和进程通信程序。

三、实验内容1. 进程控制实验：编写一个程序，实现进程的创建、调度和终止。

通过调用系统调用函数，创建多个子进程，并通过进程控制函数实现父子进程的协作与同步。

2. 进程通信实验：编写一个程序，实现进程间的信息传递和同步管理。

通过共享内存、管道、消息队列或信号量等机制，实现不同进程之间的数据交换和共享。

四、实验步骤1. 进程控制实验：（1）创建父进程和子进程：使用fork()函数创建子进程，并通过判断返回值来区分父子进程。

（2）调度子进程：使用wait()函数等待子进程的结束，以实现父子进程的同步。

（3）终止子进程：使用exit()函数终止子进程的运行。

2. 进程通信实验：（1）共享内存：使用shmget()函数创建共享内存段，使用shmat()函数映射共享内存到进程的地址空间，实现共享数据的读写。

（2）管道：使用pipe()函数创建管道，使用fork()函数创建子进程，通过读写管道实现进程间的数据传输。

（3）消息队列：使用msgget()函数创建消息队列，使用msgsnd()函数向消息队列发送消息，使用msgrcv()函数从消息队列接收消息，实现进程间的消息传递。

（4）信号量：使用semget()函数创建信号量，使用semop()函数对信号量进行P操作和V操作，实现进程间的同步和互斥。

五、实验结果通过实验，我们成功实现了进程的创建、调度和终止，以及进程间的信息传递和同步管理。

进程控制实验报告1 •目的和要求通过本实验掌握Linux操作系统的进程创建fork （）,进程终止exit （）,等待进程终止wait （），执行用户可执行程序exec （）等进程控制的操作，利用Linux操作系统提供的进程通信的工具实现进程间的同步。

2. 实验内容问题：求100000个浮点数（精确小数点右4位）的平均值（和、最大值、最小值）流程图：步骤：1、随机生成100000个浮点数（父进程）；2、创建4个子进程，分别求25000个浮点数之和；3、父进程完成100000个浮点数之和并打印结果。

4、统计顺序计算的时间和多个进程采用多道程序设计完成计算的时间。

3. 参考文献Keith Haviland 等著/《UNIX系统编程》/第二版/电子工业出版社/03年1月出版4. 实验内容1、求解问题的顺序程序及运行时间#in clude<stdio.h>#i nclude<sys/time.h>#in clude<stdlib.h>#in clude< uni std.h>int main( void){int i, j;double array[4][25000]double allsum=0.0;time_t start, end;struct timeval js;for (i = 0; i < 4; i++)for (j = 0; j < 25000; j++)array[i][j]=(double)ra nd() / (double)RAND_MAX;gettimeofday(&js, NULL);start = _usec;for (i = 0; i < 4; i++){for (j = 0; j < 25000; j++)sum[i] += array[i][j];}for ( i=0; , i< 4; i++){allsum= sum[i];prin tf("sum = %f\n", allsum);}gettimeofday(&tv, NULL);end = _usec;prin tf("time = %d\n", end -start);return 0;}运行结果为：sum=49951.056669time=14562、求解问题的多道程序设计的程序及运行时间#in clude <sys/types.h>#i nclude <sys/time.h>#in clude <uni std.h>#in clude <stdio.h>#in elude <stdlib.h>double array[4][25000];double sum[4] = {0.0}double allsum[4];double sum = 0.0;int fpipe[4][2];int mai n(void){int i, j;struct timeval tv;time_t start, end;for (i = 0; i < 4; i++)for (j = 0; j < 25000; j++)a[i][j]=(double)ra nd() / (double)RAND_MAX gettimeofday(&tv, NULL);start = _usec;for (i = 0; i < 4; i++){if (pipe(fpipe[i]) < 0){prin tf("pipe error!\n");exit(1);}if (fork() == 0) {for (j = 0; j < 25000; ++j){sum1[i] += a[i][j];}write(fpipe[i][1], &sum1[i],sizeof(double));exit(0);}else{if ( !read(fpipe[i][0], &sum[i], sizeof(double))){exit(1);}prin tf("sum[%d] = %f\n", i, sum[i]);}}for (i = 0; i< 4; i++)sum += sum[i];prin tf("sum= %f\n", sum);gettimeofday(&tv, NULL);end = _usec;printf("time= %d\n", end - start); return 0;}其结果为：Sum=49551.056669Time=5035其部分生成的数字为:0.5800 0.0670 0.4490 0.5106 0.6561 0.7088 0.5746 0.7144 0.4324 0.2044 0.0959 0.4480 0.0764 0.3211 0.0312 0.1233 0.3066 0.3779 0.0558 0.5903 0.2981 0.3085 0.6777 0.9622 0.4080 0.2521 0.0996 0.4301 0.5412 0.2261 0.0797 0.1212 0.2931 0.5287 0.6318 0.9492 0.2376 0.2065 0.6636 0.6700 0.4109 0.7596 0.1180 0.4873 0.0807 0.1492 0.6106 0.3873 0.5271 0.6664 0.9776 0.8252 0.9749 0.6553 0.7874 0.3829 0.9075 0.8870 0.8130 0.4486 0.1131 0.8927 0.5698 0.4062 0.4214 0.2017 0.3554 0.6590 0.4081 0.0190 0.3290 0.8190 0.7786 0.4470 0.3063 0.8593 0.5962 0.9169 0.2466 0.1233 0.5833 0.2242 0.9485 0.5582 0.8796 0.7359 0.9411 0.7870 0.6229 0.75410.2357 0.7360 0.6468 0.8055 0.1422 0.0683 0.0072 0.4976 0.7273 0.4153 0.5166 0.0563 0.2343 0.2952 0.5033 0.5407 0.1544 0.0995 0.4576 0.4010 0.2227 0.0409 0.6253 0.1712 0.5991 0.5049 0.9071 0.5402 0.2919 0.5300 0.2943 0.5275 0.2660 0.9411 0.3330 0.4082 0.0094 0.3402 0.9058 0.7367 0.7555 0.4224 0.7929 0.9898 0.7175 0.2962 0.5305 0.8719 0.3957 0.9881 0.2730 0.6184 0.0289 0.8983 0.7896 0.6280 0.4031 0.6968 0.1682 0.6950 0.2268 0.4625 0.2225 0.4928 0.4036 0.5555 0.9010 0.4130 0.8957 0.8068 0.1496 0.6512 0.2292 0.9426 0.6411 0.9467 0.2388 0.1716 0.8186 0.6345 0.1597 0.0916 0.2529 0.1886 0.9899 0.0425 0.8166 0.3930 0.7393 0.9848 0.0881 0.9661 0.4473 0.3106 0.4589 0.8508 0.8661 0.3599 0.2638 0.7619 0.1668 0.4134 0.4131 0.3959 0.3560 0.0541 0.3426 0.5948 0.2257 0.1613 0.2293 0.3854 0.2529 0.4822 0.5740 0.2428 0.5247 0.3907 0.6359 0.26390.3755 0.7239 0.2300 0.8227 0.0345 0.6889 0.6736 0.9006 0.0488 0.9374 0.6625 0.2156 0.3508 0.0755 0.6115 0.7068 0.1297 0.9541 0.3017 0.3554 0.1154 0.5309 0.7408 0.3683 0.0131 0.3148 0.6111 0.5378 0.7055 0.24700.8017 0.0810 0.9709 0.0317 0.9037 0.0053 0.7206 0.5773 0.9060 0.7694 0.5147 0.5684 0.9850 0.8655 0.6440 0.5966 0.5724 0.7736 0.5507 0.8740 0.1291 0.6661 0.4050 0.8699 0.0344 0.4181 0.1847 0.6455 0.9558 0.8902 0.8924 0.7575 0.9712 0.8633 0.7892 0.8749 0.8686 0.5098 0.4523 0.7746 0.2792 0.9670 0.3430 0.2643 0.8325 0.9870 0.8608 0.4048 0.7606 0.4115 0.2789 0.8897 0.0776 0.6838 0.7595 0.1120 0.1019 0.9443 0.7575 0.0577 0.8345 0.6499 0.8152 0.8057 0.5132 0.6044 0.6806 0.3818 0.1142 0.1329 0.1564 0.3935 0.0998 0.4995 0.6578 0.9323 0.4864 0.5186 0.3372 0.2471 0.9301 0.6160 0.1367 0.0077 0.2999 0.8963 0.1197 0.4018 0.8406 0.8772 0.4595 0.6750 0.5271 0.2747 0.4807 0.0403 0.8791 0.1614 0.4222 0.99330.2942 0.5786 0.3868 0.3941 0.0781 0.0446 0.3264 0.5645 0.5632 0.6635 0.8116 0.4933 0.2796 0.9484 0.5010 0.5794 0.8446 0.6207 0.9812 0.6852 0.4979 0.4407 0.3602 0.0251 0.7154 0.8410 0.0654 0.5945 0.0023 0.4876 0.5878 0.2966 0.0662 0.9746 0.6906 0.1443 0.0192 0.0170 0.7089 0.58240.6806 0.5205 0.0756 0.9602 0.4688 0.5766 0.5396 0.3135 0.1974 0.5208 0.9987 0.6953 0.9615 0.3589 0.7204 0.6769 0.1999 0.7858 0.2713 0.2022 0.2734 0.8591 0.4988 0.3396 0.8338 0.1894 0.4840 0.8530 0.2064 0.1928 0.4353 0.8870 0.7133 0.5110 0.8472 0.1821 0.0876 0.3868 0.4956 0.2850 0.9076 0.4942 0.9803 0.8691 0.8531 0.7007 0.5459 0.0530 0.4865 0.81720.2552 0.7599 0.6764 0.7540 0.0996 0.5101 0.9434 0.5835 0.3631 0.1499 0.7763 0.7984 0.0369 0.4896 0.3094 0.8840 0.6717 0.3970 0.2708 0.1673 0.6819 0.1784 0.6615 0.6622 0.0474 0.5146 0.3629 0.5933 0.5677 0.8494 0.4106 0.8229 0.6093 0.0869 0.5769 0.7089 0.5971 0.5204 0.2924 0.96020.6703 0.0687 0.7586 0.7071 0.5583 0.0680 0.5912 0.2300 0.4649 0.8620 0.3973 0.1469 0.0404 0.0588 0.8091 0.0878 0.5735 0.1721 0.6811 0.14110.0215 0.0917 0.9641 0.6308 0.1786 0.5410 0.3397 0.7757 0.0614 0.6322 0.7358 0.7317 0.7009 0.4944 0.4388 0.2592 0.5624 0.0300 0.4893 0.0273 0.8920 0.8866 0.1742 0.9323 0.9454 0.9834 0.0201 0.5189 0.1554 0.7012 0.6600 0.1769 0.7929 0.6241 0.8077 0.9715 0.1651 0.1475 0.7472 0.2265 0.7796 0.4830 0.9581 0.4805 0.9774 0.3969 0.7398 0.5398 0.4269 0.2291 0.5671 0.3189 0.1157 0.7414 0.2512 0.0611 0.7247 0.2713 0.5800 0.8801 0.9725 0.2400 0.0570 0.7654 0.8640 0.8648 0.7369 0.0291 0.0123 0.4841 0.2555 0.7919 0.9671 0.2136 0.2724 0.9445 0.6105 0.0122 0.4844 0.0374 0.2413 0.0515 0.3563 0.3569 0.7929 0.6074 0.4180 0.5176 0.8787 0.9980 0.3977 0.8513 0.2379 0.4548 0.6167 0.1020 0.3195 0.3536 0.1310 0.3318 0.8377 0.3866 0.1237 0.8049 0.6002 0.3961 0.7494 0.2107 0.4083 0.23380.2481 0.6496 0.2852 0.6044 0.0065 0.0781 0.2118 0.4245 0.5957 0.0906 0.4225 0.9934 0.9418 0.6605 0.4482 0.5585 0.7624 0.7677 0.9122 0.8934 0.0995 0.7499 0.2800 0.2231 0.5548 0.8802 0.6192 0.3042 0.0909 0.02750.5379 0.3391 0.6771 0.8232 0.9435 0.6836 0.9013 0.1553 0.1082 0.4970 0.2459 0.5307 0.4904 0.1877 0.1911 0.9385 0.7462 0.9536 0.7062 0.6584 0.8470 0.8057 0.4083 0.1270 0.0288 0.9631 0.0072 0.6480 0.2672 0.0982 0.6756 0.8051 0.4372 0.3526 0.6283 0.3807 0.0363 0.5296 0.5360 0.1444 0.0265 0.7818 0.6751 0.5169 0.9695 0.8662 0.4554 0.7157 0.8198 0.1617 0.3741 0.6668 0.9674 0.7824 0.7938 0.9962 0.7455 0.8010 0.6442 0.0127 0.8992 0.3198 0.8178 0.3364 0.6724 0.4461 0.7171 0.7087 0.9757 0.25310.8531 0.0022 0.0349 0.5282 0.5191 0.0044 0.3944 0.9746 0.7202 0.2142 0.1362 0.0943 0.8810 0.1036 0.8767 0.6748 0.0998 0.6222 0.4758 0.7441 0.6349 0.3750 0.0639 0.4527 0.7114 0.7363 0.8989 0.4285 0.4450 0.87460.6816 0.2981 0.8768 0.7165 0.8263 0.3959 0.7209 0.2207 0.3705 0.4411 0.4349 0.5068 0.5353 0.3159 0.6104 0.4121 0.9907 0.7102 0.0343 0.4665 0.4543 0.6692 0.8415 0.5181 0.1219 0.5530 0.2544 0.0208 0.9815 0.6994 0.8954 0.6631 0.9976 0.7722 0.3796 0.8239 0.1681 0.1005 0.0446 0.5387 0.5415 0.4795 0.0454 0.0769 0.7955 0.6558 0.4890 0.7862 0.3660 0.52320.2527 0.8203 0.1924 0.0942 0.3384 0.3143 0.6472 0.5928 0.3351 0.6287 0.2923 0.2305 0.2918 0.2898 0.0027 0.6714 0.1137 0.1708 0.7719 0.1583 0.7095 0.3134 0.6378 0.7549 0.3903 0.4333 0.4108 0.8793 0.2195 0.7768 0.4025 0.4722 0.5971 0.5949 0.5664 0.9355 0.9092 0.2136 0.5283 0.24430.8423 0.8206 0.4748 0.1342 0.1105 0.4775 0.8056 0.2242 0.6483 0.5774 0.3825 0.3578 0.8909 0.0203 0.1127 0.2812 0.4536 0.5235 0.1605 0.6731 0.3003 0.5630 0.1453 0.8974 0.1579 0.7117 0.8329 0.0670 0.9253 0.3612 0.3113 0.7676 0.1818 0.7861 0.9018 0.2923 0.2635 0.7073 0.5165 0.9118 0.2848 0.8989 0.2696 0.1757 0.9193 0.3824 0.4569 0.3729 0.9059 0.6173 0.0460 0.2062 0.1803 0.1912 0.1036 0.3382 0.9029 0.9364 0.4052 0.8282 0.2976 0.7165 0.5958 0.4795 0.5026 0.4976 0.7718 0.7661 0.2049 0.2882 0.6780 0.4897 0.1871 0.9476 0.6654 0.1064 0.3300 0.1222 0.4793 0.2359 0.7396 0.5253 0.4420 0.9199 0.7165 0.5456 0.2581 0.6194 0.4820 0.6633 0.4476 0.7797 0.3798 0.0435 0.2591 0.8824 0.5411 0.0309 0.6485 0.7460 0.3191 0.3265 0.2357 0.5062 0.2741 0.9011 0.6126 0.6041 0.0233 0.0919 0.8399 0.7629 0.6172 0.2819 0.6828 0.3337 0.8275 0.9408 0.9531 0.3095 0.6041 0.4007 0.0892 0.9839 0.4442 0.3483 0.8663 0.9852 0.3792 0.5148 0.7312 0.6983 0.8413 0.9669 0.2045 0.1154 0.8680 0.8171 0.7195 0.8913 0.9090 0.5594 0.6542 0.5262 0.8414 0.3369 0.8599 0.6689 0.2778 0.8129 0.9784 0.8819 0.2137 0.0676 0.8658 0.6578 0.4160 0.7321 0.6430 0.7952 0.2470 0.3743 0.4935 0.0883 0.3412 0.6980 0.2037 0.2092 0.5152 0.9232 0.1005 0.4242 0.4827 0.7546 0.9504 0.3240 0.0916 0.8102 0.9929 0.3693 0.6232 0.9713 0.2512 0.8369 0.0390 0.1170 0.4947 0.4549 0.8492 0.1377 0.2501 0.0961 0.5120 0.7436 0.1844 0.8532 0.4416 0.3882 0.0623 0.9568 0.3114 0.1628 0.3810 0.7941 0.9174 0.3314 0.1181 0.0090 0.1416 0.1110 0.3783 0.7648 0.0824 0.6295 0.6017 0.1213 0.7466 0.0964 0.5763 0.59570.2341 0.8264 0.6919 0.7461 0.5700 0.8763 0.5992 0.0117 0.2645 0.6616 0.9685 0.5759 0.8244 0.3495 0.3700 0.7417 0.6809 0.4881 0.7507 0.8225 0.5992 0.1290 0.5873 0.6815 0.7585 0.1890 0.8029 0.5051 0.2853 0.37920.1008 0.5194 0.2056 0.7926 0.2655 0.7756 0.6689 0.8648 0.7873 0.9334 0.5263 0.7558 0.5093 0.3507 0.1053 0.8794 0.0924 0.7861 0.3675 0.8431 0.6086 0.9667 0.9721 0.1960 0.6482 0.7306 0.3850 0.4511 0.2357 0.6703 0.8303 0.3365 0.1897 0.0358 0.1292 0.4552 0.8115 0.7981 0.3200 0.5988 0.7315 0.8463 0.3546 0.2409 0.1970 0.4598 0.1202 0.2894 0.2460 0.48770.1326 0.8546 0.4544 0.1047 0.0506 0.1026 0.8353 0.4355 0.5537 0.0711 0.1058 0.3840 0.4076 0.2956 0.4198 0.5368 0.7508 0.2313 0.3349 0.0708 0.8300 0.0664 0.9171 0.1846 0.3073 0.1141 0.6444 0.4275 0.4036 0.8904 0.9152 0.5362 0.7450 0.3696 0.6408 0.7956 0.4723 0.4762 0.2311 0.0259 0.5473 0.3370 0.4099 0.9548 0.6325 0.8297 0.4916 0.3833 0.0610 0.8265 0.4542 0.8910 0.8929 0.3713 0.0756 0.2002 0.4854 0.7200 0.6277 0.8890 0.6104 0.5430 0.4252 0.3554 0.9126 0.0660 0.1510 0.3849 0.5422 0.3821 0.4108 0.0895 0.7191 0.8207 0.0443 0.3516 0.6504 0.5359 0.7349 0.7114 0.3624 0.1891 0.6024 0.2553 0.5604 0.6779 0.4555 0.0458 0.3979 0.0832 0.9348 0.0083 0.6262 0.3600 0.3636 0.5388 0.4261 0.5146 0.9236 0.96830.8967 0.3345 0.0577 0.6158 0.1552 0.1021 0.9673 0.8056 0.6380 0.7023 0.5170 0.0004 0.8913 0.1193 0.2557 0.4517 0.7972 0.7112 0.4975 0.1951 0.7944 0.4324 0.2034 0.4206 0.7924 0.5670 0.9594 0.2184 0.0817 0.8831 0.1867 0.9784 0.2175 0.2444 0.5941 0.3727 0.3465 0.5614 0.1783 0.98450.2637 0.6952 0.9849 0.1550 0.8145 0.2406 0.6067 0.6118 0.9518 0.1042 0.8069 0.7463 0.5366 0.0103 0.1669 0.3290 0.5773 0.1263 0.5474 0.6590 0.0094 0.7341 0.6374 0.2269 0.9786 0.2315 0.5996 0.3250 0.7929 0.7779 0.3095 0.0566 0.4731 0.2944 0.2116 0.2877 0.5350 0.8184 0.8994 0.4868 0.9226 0.7063 0.2331 0.4592 0.7166 0.3999 0.7881 0.2940 0.5263 0.33560.9530 0.5356 0.0697 0.5903 0.7625 0.0482 0.8218 0.3621 0.3733 0.6147 0.1400 0.6828 0.6713 0.6131 0.9772 0.8830 0.9008 0.5122 0.7013 0.8002 0.9990 0.6239 0.5065 0.2320 0.0831 0.2231 0.6320 0.8713 0.5171 0.15820.2068 0.4700 0.6939 0.2765 0.0604 0.4564 0.3247 0.8821 0.8185 0.6979 0.4969 0.9585 0.3807 0.1682 0.5717 0.3579 0.0511 0.4724 0.8701 0.7525 0.2726 0.8691 0.3764 0.7792 0.1011 0.4595 0.0023 0.7331 0.3308 0.5194 0.8913 0.5376 0.9894 0.5852 0.8140 0.0498 0.0416 0.1387 0.9320 0.8601 0.8367 0.4288 0.8186 0.2174 0.5970 0.3903 0.5753 0.6481 0.8627 0.4454 0.4006 0.1354 0.3144 0.7770 0.9146 0.4155 0.2365 0.9169 0.1486 0.5673 0.4363 0.0399 0.1048 0.42570.6251 0.9189 0.47555.心得体会本以为多道程序设计出来的代码在运行时间上比顺序的要短，但是实际上由于现在的PC机都是单CPU和CPU单核的比较多，包括我自己的。

《操作系统原理》实验报告
实验序号：4 实验项目名称：进程控制
一、实验目的及要求
1. 加深对进程信号量的理解。

2. 理解进程同步与互斥机制。

3. 掌握Linux操作系统下的进程控制编程。

二、实验设备（环境）及要求
1.虚拟机VMware Workstation、Ubuntu操作系统和C语言编程。

2.编写一段程序，使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按Ctrl C键），当捕捉到中断信号后，父进程调用kill()向两个子进程发出信号，子进程捕捉到信号后，分别输出下面信息后终止：
child process 1 is killed by parent!
child process 2 is killed by parent!
父进程等待两个子进程终止后，输出以下信息后终止：
parent process is killed!
三、实验内容与步骤
代码：
在终端上进行测试
四、实验结果与数据处理
五、分析与讨论
了解了计算机进程的管理以及signal（）函数的作用。

六、教师评语成绩。

操作系统进程控制实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程控制的概念和机制，通过实际操作和观察，掌握进程的创建、终止、阻塞和唤醒等基本操作，以及进程间的通信和同步方法。

二、实验环境本次实验在装有 Windows 10 操作系统的计算机上进行，使用 C 语言作为编程语言，编译环境为 Visual Studio 2019。

三、实验原理1、进程的概念进程是操作系统中进行资源分配和调度的基本单位，它由程序、数据和进程控制块（PCB）组成。

2、进程的状态进程通常具有就绪、运行和阻塞三种基本状态。

就绪状态表示进程已经准备好执行，只等待被调度；运行状态表示进程正在CPU 上执行；阻塞状态表示进程由于等待某个事件而暂停执行。

3、进程控制进程控制通过操作系统提供的系统调用实现，包括创建进程（CreateProcess）、终止进程（TerminateProcess）、阻塞进程（WaitForSingleObject）和唤醒进程（SetEvent）等。

4、进程间通信进程间通信的方式有多种，如共享内存、消息队列、管道等。

在本次实验中，我们主要使用信号量来实现进程间的同步。

四、实验内容及步骤1、创建进程使用 CreateProcess 函数创建一个子进程，子进程执行一个简单的计算任务，计算 1 到 100 的和，并将结果输出到控制台。

｀｀｀cinclude ＜windowsh>include ＜stdioh>DWORD WINAPI ChildProcess(LPVOID lpParam)｛int sum ＝ 0;for （int i ＝ 1; i ＜＝ 100; i+＋）｛sum ＋＝ i;｝printf(＂Child Process: The sum from 1 to 100 is ％d\n"， sum)；return 0;｝int main(）｛STARTUPINFO si;PROCESS_INFORMATION pi;ZeroMemory(＆si, sizeof(si)）；sicb ＝ sizeof(si)；ZeroMemory(＆pi, sizeof(pi)）；if （！CreateProcess(NULL, ＂ChildProcess"， NULL, NULL, FALSE, 0, NULL, NULL, ＆si, ＆pi)）｛printf(＂CreateProcess failed （％d)＼n"， GetLastError(））；return 1;｝WaitForSingleObject(pihProcess, INFINITE)；CloseHandle(pihProcess)；CloseHandle(pihThread)；return 0;｝｀｀｀2、终止进程在父进程中使用 TerminateProcess 函数强制终止子进程，并观察终止后的效果。

第1篇一、实验目的本次实验旨在通过实际操作，让学生深入理解Linux操作系统的进程管理机制，掌握进程的创建、调度、同步与通信等基本概念和操作方法。

通过实验，使学生能够熟练运用Linux命令和编程技术，解决实际问题。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 实验工具：xshell、gcc三、实验内容本次实验主要包括以下内容：1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程通信四、实验步骤1. 进程的创建与终止（1）使用fork()函数创建子进程：```cpid_t pid = fork();if (pid == 0) {// 子进程代码} else if (pid > 0) {// 父进程代码} else {// 创建子进程失败}```（2）使用wait()函数等待子进程结束：```cint status;waitpid(pid, &status, 0);```（3）使用kill()函数终止进程：```ckill(pid, SIGTERM);```2. 进程的调度与优先级（1）使用nice()函数调整进程优先级：```cnice(-n); // 降低进程优先级```（2）使用renice()函数实时调整进程优先级： ```crenice(n, pid);```3. 进程同步与互斥（1）使用互斥锁（mutex）实现进程互斥：```cpthread_mutex_t mutex;pthread_mutex_init(&mutex, NULL);pthread_mutex_lock(&mutex);// 临界区代码pthread_mutex_unlock(&mutex);pthread_mutex_destroy(&mutex);```（2）使用条件变量（condition variable）实现进程同步： ```cpthread_cond_t cond;pthread_cond_init(&cond, NULL);pthread_cond_wait(&cond, &mutex);// 条件满足后的代码pthread_cond_signal(&cond);pthread_cond_destroy(&cond);```4. 进程通信（1）使用管道（pipe）实现进程间通信：```cint pipefd[2];pipe(pipefd);// 父进程dup2(pipefd[1], STDOUT_FILENO);// 子进程dup2(pipefd[0], STDIN_FILENO);```（2）使用消息队列（message queue）实现进程间通信： ```ckey_t key = ftok("queuefile", 'q');int msqid = msgget(key, 0666 | IPC_CREAT);// 发送消息struct msgbuf msg;msg.mtype = 1;strcpy(msg.mtext, "Hello");msgsnd(msqid, &msg, strlen(msg.mtext), 0);// 接收消息msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0);printf("%s\n", msg.mtext);```五、实验结果与分析通过本次实验，我们成功实现了以下功能：1. 创建并管理多个进程；2. 调整进程优先级；3. 实现进程同步与互斥；4. 实现进程间通信。

一、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。

2. 进一步认识并发执行的实质，理解进程的创建、调度、同步与通信。

3. 学习使用Linux系统中的进程管理命令，掌握进程的监控、控制与优化。

二、实验环境操作系统：Linux Ubuntu 20.04实验工具：终端（Terminal）、shell命令三、实验内容1. 进程的基本概念与特性2. 进程的创建与调度3. 进程同步与通信4. 进程的监控与优化四、实验步骤1. 进程的基本概念与特性（1）通过阅读相关资料，了解进程的概念、特性和生命周期。

（2）使用shell命令查看当前系统中进程的状态，如ps、top、htop等。

2. 进程的创建与调度（1）使用fork()函数创建进程，观察父子进程之间的关系。

（2）使用exec()函数替换子进程的映像，实现进程的创建。

（3）使用wait()、waitpid()等函数等待子进程结束，控制进程执行顺序。

（4）通过修改进程优先级，观察进程调度策略的变化。

3. 进程同步与通信（1）使用互斥锁（mutex）实现进程同步，防止数据竞争。

（2）使用条件变量（condition variable）实现进程间的条件同步。

（3）使用信号量（semaphore）实现进程间的同步与通信。

（4）通过管道（pipe）、消息队列（message queue）、共享内存（shared memory）等机制实现进程间的通信。

4. 进程的监控与优化（1）使用ps、top、htop等命令监控进程的运行状态。

（2）通过调整进程优先级，优化进程的执行顺序。

（3）使用renice命令调整进程的实时性。

（4）使用nice命令调整进程的调度策略。

五、实验结果与分析1. 进程的基本概念与特性通过实验，我们了解到进程是具有一定独立功能的程序关于某个数据集合的一次运行活动，具有并发性、动态性、独立性、异步性和结构特征等特性。

2. 进程的创建与调度实验过程中，我们成功创建了多个进程，并通过修改进程优先级，观察到调度策略的变化。

进程控制与进程通信程序实验报告1. 背景进程控制与进程通信是操作系统的重要概念之一，它们在现代计算机系统中起到了至关重要的作用。

进程控制是指操作系统对进程的创建、执行、中止和切换等各种操作的管理和控制，进程通信则是指进程之间通过各种方式传递信息和实现协作的机制。

在本次实验中，我们需要编写一个进程控制与进程通信程序。

通过实现进程的创建、执行和中止等基本操作，并通过进程通信机制进行信息传递，实现多个进程之间的协作。

本实验将帮助我们进一步理解和掌握进程控制与进程通信的原理和操作。

2. 分析2.1 实验要求本次实验要求我们编写一个进程控制与进程通信程序，实现以下功能：1.创建一个主进程和多个子进程，并实现进程的执行和切换；2.子进程之间通过进程通信机制传递信息；3.实现多个子进程之间的协作，完成指定的任务。

2.2 系统设计为了满足实验的要求，我们可以按照以下步骤设计我们的系统：1.创建主进程和多个子进程：使用操作系统提供的进程创建函数，创建一个主进程和多个子进程。

主进程将负责协调子进程的执行和协作。

2.进程执行和切换：使用操作系统提供的进程执行和切换函数，实现进程的执行和切换操作。

主进程可以通过改变进程的状态和优先级来控制进程的执行和切换。

3.进程通信机制：使用操作系统提供的进程通信机制，如消息队列、共享内存等，实现子进程之间的信息传递。

可以定义统一的消息格式，并使用相应的函数进行消息的发送和接收。

4.进程协作：根据实验要求，设计子进程之间的协作方式。

可以使用信号量、条件变量等机制来实现多个子进程之间的同步和互斥。

2.3 实验结果实验的结果将是一个能够创建多个子进程，并通过进程通信进行协作的程序。

程序将实现以下功能：1.主进程创建多个子进程，并通过改变进程的状态和优先级来控制进程的执行；2.子进程通过进程通信机制传递信息，完成指定的任务；3.子进程之间通过协作实现同步和互斥，保证任务的正确执行。

3. 实验步骤3.1 创建进程首先，我们需要创建主进程和多个子进程。

进程控制实验报告进程控制实验报告一、实验目的本实验旨在通过实际操作，深入理解进程控制的概念、原理和实现方式，掌握进程控制的技巧和方法，提升解决实际问题的能力。

二、实验原理进程控制是操作系统内核的重要功能之一，它负责协调和管理系统中多个进程的执行顺序和资源分配。

进程控制的主要任务包括创建和终止进程、进程切换和进程同步等。

本实验将通过具体的操作，学习和体验进程控制的过程和细节。

三、实验步骤1.实验准备（1）了解和熟悉实验室环境，包括计算机硬件配置、操作系统版本等信息。

（2）准备实验材料，包括相关文档、软件工具等。

（3）明确实验任务和目的，制定实验计划。

2.创建进程（1）打开实验环境，启动操作系统。

（2）使用编程语言（如C语言）编写一个简单的程序，该程序将创建一个新的进程。

（3）编译并运行程序，观察和记录进程的创建过程。

3.进程切换（1）编写一个程序，该程序将在两个进程之间进行切换。

（2）运行程序，观察和记录进程切换的过程和效果。

4.进程同步（1）使用信号量或其他同步机制实现两个进程的同步。

（2）运行程序，观察和记录进程同步的过程和效果。

5.进程终止（1）编写一个程序，该程序将终止一个指定的进程。

（2）运行程序，观察和记录进程终止的过程和效果。

6.实验总结与报告编写（1）总结实验过程和结果，梳理实验中的问题和解决方法。

（2）编写实验报告，包括实验目的、原理、步骤、结果分析等。

四、实验结果与分析通过本次实验，我们成功地创建了一个新的进程，并实现了进程之间的切换、同步和终止。

在实验过程中，我们深入理解了进程控制的概念、原理和实现方式，掌握了进程控制的技巧和方法。

同时，我们也遇到了一些问题，如进程创建失败、进程切换不成功等，但通过仔细分析问题原因并采取相应的解决方法，最终成功解决了这些问题。

通过本次实验，我们不仅学到了专业知识，也提高了解决实际问题的能力。

五、实验结论与建议本次实验让我们更加深入地理解了进程控制的相关知识，并掌握了进程控制的基本操作方法。

课程名称：操作系统实验名称：进程的控制班级：092017姓名：江波同组人：___________________________指导教师评定：_____________________ 签名：__________________________一、实验目的：1.熟悉Linux环境2.知道如何在Linux环境下如何编写C语言程序3.知道如何在Linux环境下进程是如何被控制和管理的二、实验要求：在Linux环境下用记事本编写如下代码，并对其进行编译和运行，观察执行时屏幕上出现的现象，并分析其原因，然后再对代码进行适当的修改再观察执行时的现象并分析其原因。

#include <stdio.h>main (){int p1 , p2 , i;while ((p1= fork ()) < 0 ) ;if( p1 == 0 )for (i = 0 ; i< 50 ; i++)printf (“child %d\n” , i) ;else{ while (( p2 = fork ()) <0 ) ;if ( p 2 == 0 )for ( i= 0 ; i < 50 ;i++ )printf ( “son%d \n ”, I )elsefor ( i = 0 ;i < 50 ;i++ )printf (“daughter %d \n ”, i ) ;}}三、实验步骤：（1）登入Linux虚拟机。

（2）在虚拟机环境下用记事本编写上面代码，保存完之后在终端里面对它进行调试、编译和运行。

（3）观察运行结果，得出结论。

（4）再修改部分代码并调试、编译、运行观察结果。

四、实验结果：Child0Child1Child2Child4Child5Child6Child7Child8Child9...Son0Son1Son2Child3Son3Son5Son6Son7Son8Son9...Daughter0Daughter1Daughter2Son4Daughter3Daughter4Daughter5Daughter6Daughter7Daughter8Daughter9...五、实验感想：由于函数printf()输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。