FZU操作系统课程实验 实验一

实验1

【实验名称】：并发程序设计（实验1）

【实验目的】：掌握在程序中创建新进程的方法， 观察并理解多道程序并发运行的现象。

【实验原理】：fork():建立子进程。子进程得到父进程地址空间的一个复制。

返回值：成功时，该函数被调用一次，但返回两次，fork（）对子进程返回0，对父进程返回子进程标识符（非0值）。不成功时对父进程返回-1，没有子进程。

【实验内容】：首先分析一下程序执行时其输出结果有哪几种可能性，然后实际调试该程序观察事实上际输出情况，比較两者的差异，分析当中的原因。

void main (void)

{

int   x=5;

if( fork( ) )

{

x+=30;

printf (“%d\n”,x);

}

else

printf(“%d\n”,x);

printf((“%d\n”,x);

}

【实验要求】：每一个同学必须独立完毕本实验、提交实验报告、源程序和可运行程序。实验报告中必须包括估计的实验结果，关键代码的分析，调试记录，实际的实验结果，实验结果分析等内容。

一．关键代码分析

值而父进程中返回子进程ID。

子进程是父进程的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程间不共享这些存储空间。

也就是说，当程序执行到if条件推断执行fork（）函数后，父进程执行的是条件成立成立的代码，即

x+=30;

printf (“%d\n”,x);

子进程执行的是条件不成立的代码，即

printf(“%d\n”,x);

依据并发运行的工作方式及特征，我们估计可能的实验结果例如以下：

二．估计实验结果

推測有6种情况（事实上就是这4个数的全排列）

35	35	35	5	5	5
35	5	5	5	35	35
5	35	5	35	5	35
5	5	35	35	35	5

三．调试记录

1. 先建立一个.c为后缀的文档，如test.c

2. 编辑源程序：

#include<stdio.h>

#include<unistd.h>

void main (void)

{

int   x=5;

if( fork( ) )

{

x+=30;

printf (“%d\n”,x);

}

else

printf(“%d\n”,x);

printf((“%d\n”,x);

}

3. 在命令行下编辑 gcc –o test.out test.c

然后编辑       ./test.out

执行程序

4. 实际实验结果：

35

35

（一串字符命令，省略）5

5

（PS：那段字符命令，父进程执行完就会出现，所以都是在输出两个35后出现）

反复步骤3，N次后发现还是这个结果。

四．实验结果分析

老师说其他结果的出现是小概率事件。我们不敢苟同，这都基本上能够当不可能事件处理了。

于是我们推測，这个跟传说中的时间片有关。

由于这个程序执行所需的时间实在是太短，默认先执行的父进程全然能够在系统给定的时间片内执行完，假设没有出现什么其它情况而挂起，子进程就仅仅能等到父进程执行完后才干执行。

所以呢，当然就仅仅有一种情况了。

五．实验结果处理

只是，我们能够利用时间片的特性制造出6种结果。

主角登场了，sleep(1) 延时一秒函数

能够把延时函数理解为一段要执行1秒的代码。以下的提到的进程，都是因在这段延时代码中执行时进程时间片用完挂起（如果在这个延时代码中执行了0.6秒），再次调度回来时，仅仅要再执行0.4秒就能够了跳出这个延时函数了。

第一种：

由于默认先执行的是父进程（我用的系统是这样），我们感觉对子进程太不公平了，所以我们制造的第一种情况的源代码是：

#include<stdio.h>

#include<unistd.h>

void main (void)

{    int   x=5;

if( fork( ) )

{

x+=30;

sleep(1);

printf (“%d\n”,x);

}

else

printf(“%d\n”,x);

printf((“%d\n”,x);

}

我们推測时间片是0.6秒，无论对不正确，重点是分析。

父进程执行0.6秒后，时间片用完挂起，调度执行子进程，子进程执行完后调度回父进程接着执行。所以我们推測结果是

5

5

35

35

（一串字符命令，省略）

哇塞，执行完也是！

另外一种：

这里我们突然想到假设在子进程前也加个延时函数会如何，

#include<stdio.h>

#include<unistd.h>

void main (void)

{    int   x=5;

if( fork( ) )

{

x+=30;

sleep(1);

printf (“%d\n”,x);

}

else {

sleep(1);

printf(“%d\n”,x);

}

printf((“%d\n”,x);

}

只是，这个仅仅能调试完再依据答案去分析，由于我们也不知道真正的时间片是多少，仅仅是推測。执行结果为

35

35

（一串字符命令，省略）5

5

我们继续如果时间片为0.6秒，父进程执行0.6秒后挂起，轮到子进程执行0.6秒后也挂起，调度回父进程继续执行，由于之前已经执行了0.6秒，所以这次调度时间片就够用了。如果成立

所以，下面都是如果时间片为0.6秒，这个时间是非常合理的。

第三种：

#include<stdio.h>

#include<unistd.h>

void main (void)

{

int   x=5;

if( fork( ) )

{

x+=30;

sleep(1);

printf (“%d\n”,x);

}

else {

printf(“%d\n”,x);

sleep(1);

}

printf((“%d\n”,x);

}

与前面的分析类似，父进程执行0.6秒后挂起，调度子进程会先执行第一条指令输出x为5，然后进入延时函数执行0.6秒（前面执行1条指令的时间能够忽略不计）后挂起，调度回父进程执行完，再调度回子进程。所以输出为

5

35

35

（一串字符应该是提示输入的命令，省略）5

第四种：

#include<stdio.h>

#include<unistd.h>

void main (void)

{    int   x=5;

if( fork( ) )

{

x+=30;

printf (“%d\n”,x);

sleep(1);

}

else {

printf(“%d\n”,x);

sleep(1);

}

printf((“%d\n”,x);

}

分析同上，输出结果为

35

5

35

（一串字符命令，省略）5

第五种:

#include<stdio.h>

#include<unistd.h>

void main (void)

{    int   x=5;

if( fork( ) )

{

x+=30;

printf (“%d\n”,x);

sleep(1);

}

else {

printf(“%d\n”,x);

}

printf((“%d\n”,x);

}

执行结果为,

35

5

5

35

(一串字符命令，省略)

第六种：

细致看下上面5种情况，会发现还有种比較奇葩的没有出现。

5

35

5

35

（一串字符命令，省略）

须要从父进程(延时挂起)->子进程（输出然后延时挂起）->父进程（延时然后输出然后再延时挂起）->子进程（输出结束进程）->父进程（延时然后输出结束进程），代码为

#include<stdio.h>

#include<unistd.h>

void main (void)

{    int   x=5;

if( fork( ) )

{

x+=30;

sleep(1);

printf (“%d\n”,x);

sleep(1);

}

else {

printf(“%d\n”,x);

sleep(1);

}

printf((“%d\n”,x);

}