实验目的

1. 掌握进程的概念，明确进程和程序的区别。
2. 认识和了解并发执行的实质。
3. 分析进程争用资源的现象，学习解决进程互斥的方法。
4. 了解什么是信号。
5. 熟悉 LINUX 系统中进程之间软中断通信的基本原理。

实验环境

Tencent 云服务器一台

实验内容

1 进程控制

1.1 题目

编写一段程序，使用系统调用 fork() 创建两个子进程，在系统中有一个父进程和两个 子进程活动。让每个进程在屏幕上显示一个字符；父进程显示字符“a” ，子进程分别显示 字符“b” 和“c” 。试观察记录屏幕上的显示结果，并分析原因。

代码如下：

void ForkProcess1()
{int p1, p2;while((p1 = fork()) == -1);if(p1 == 0) putchar('b');       // children processelse { while((p2 = fork()) == -1); // parent processif(p2 == 0) putchar('c');   // children processelse putchar('a');          // parent process}
}

运行以上代码，得到实验结果如下：

分析：利用 fork() 判断所属的进程。若返回值为 0 则为子进程，否则则为父进程，若为 -1 则表示创建失败。根据代码，父进程分两次产生两个子进程，分别输出 “b”，“c”，父进程输出 “a”

1.2 题目

修改已编写的程序，将每个进程的输出由单个字符改为一句话，再观察程序执行时屏幕上出现的现象，并分析其原因。

代码如下

void ForkProcess2()
{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); // parent processif(p2 == 0)   // children process{for(i = 0;i < 500;i ++){printf("son%d\n",i);}}else{for(i = 0;i < 500;i ++){printf("daughter%d\n",i);} }}
}

实验部分结果如下：

我们可以看到实验按照 daughter → child → son 的顺序执行，并没有出现中间切换的现象，这可能是因为循环运行时间较短，没有出现多个进程争抢使用 IO 资源的情况。

1.3 题目

编写程序创建进程树如图1和图2所示，在每个进程中显示当前进程识别码和父进程识别码。

图一代码如下：

void ForkProcess3()
{int  p1,p2,p3;while((p1 = fork()) == -1);if(p1 == 0){while((p2 = fork()) == -1);        if(p2 == 0){while((p3 = fork()) ==-1);        if(p3 == 0){printf("I am D,My pid is %d, my parent's pid is %d\n", getpid(), getppid());}else{printf("I am C,My pid is %d, my parent's pid is %d\n", getpid(), getppid());}}else{printf("I am B,My pid is %d, my parent's pid is %d\n", getpid(), getppid());}}else{printf("I am A,My pid is %d\n", getpid());}}

结果如下：

图二代码如下：

void ForkProcess4()
{int p1,p2,p3,p4;while((p1 = fork()) == -1);if(p1 == 0){printf("I am B,My pid is %d, my parent's pid is %d\n", getpid(), getppid());while((p2 = fork()) == -1);if(p2 == 0){printf("I am C,My pid is %d, my parent's pid is %d\n", getpid(), getppid());}}else {printf("I am A,My pid is %d\n",getpid());while((p3 = fork()) == -1);if(p3 == 0){printf("I am D,My pid is %d, my parent's pid is %d\n", getpid(), getppid());while((p4 = fork()) == -1);if(p4 == 0){printf("I am E,My pid is %d, my parent's pid is %d\n", getpid(), getppid());}}}getchar();
}

运行结果如下：

2 信号机制

2.1 题目

编写一段程序，使用系统调用 fork() 创建两个子进程，再用系统调用 signal() 让父 进程捕捉键盘上来的中断信号（即按 ctrl+c 键） ，当捕捉到中断信号后，父进程用系统调用 kill() 向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出以下信息后终止： Parent process is killed!

实验代码如下：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>int wait_mark;void waiting()
{ while(wait_mark != 0); 
}void stop()
{ wait_mark = 0;
} int main() 
{ int p1, p2;signal(SIGINT, stop);while((p1 = fork()) == -1);if(p1 > 0){while((p2 = fork()) == -1);if(p2 > 0){wait_mark = 1; waiting(); kill(p1,10); kill(p2,12); wait(); wait(); printf("parent process is killed!\n"); exit(0); }else { wait_mark = 1;signal(12,stop);waiting();lockf(1,1,0);printf("child process 2 is killed by parent!\n");lockf(1,0,0);exit(0);} }  else { wait_mark = 1;signal(10,stop);waiting();lockf(1,1,0);printf("child process 1 is killed by parent!\n");lockf(1,0,0);exit(0);}
}

实验结果：

Q：运行程序并分析结果。

运行程序我们可以看到，当从控制台输入 Ctrl + C 时，父进程和子进程 1 2 都结束了，这是因为在 fork() 产生函数之前，我们定义了 singal() 函数用于捕捉控制台的中断指令，一旦检测到指定，便向控制每个进程中的 wait_mark=0 ，从而打破 waiting() 等待条件，退出子进程和父进程。

Q：如果把 signal(SIGINT, stop) 放在 ① 号和 ② 号位置，结果会怎样并分析原因。

位于 ① 号位置时，实验结果如下：

位于 ② 号位置时，实验结果如下：

signal(SIGINT, stop)函数位于不同的位置，会产生不同的结果，原因在于函数与 fork() 产生子进程的相对位置不同。若信号接受函数在产生子进程之前，则子进程继承父进程的信号接受功能；反之，则无法行使正常的信号接收发送功能。

Q：该程序段前面部分用了两个 wait(0)，为什么？

等待子进程运行结束。如果子进程没有完成，父进程一直等待。wait() 将调用进程挂起，直至其子进程因暂停或终止而发来软中断信号为止。如果在 wait() 前已有子进程暂停或终止，则调用进程做适当处理后便返回。

Q：该程序段中每个进程退出时都用了语句 exit(0)，为什么？

UNIX/LINUX 利用 exit() 来实现进程的自我终止，通常父进程在 创建子进程时，应在进程的末尾安排一条 exit()，使子进程自我终止。exit(0)表示进程 正常终止，exit(1) 表示进程运行有错，异常终止。 如果调用进程在执行 exit() 时，其父进程正在等待它的终止，则父进程可立即得到其 返回的整数。

2.2 题目

修改上面的程序， 增加语句 signal(SIGINT,SIG_IGN) 和语句 signal(SIGQUIT,SIG_IGN)，再观察程序执行时屏幕上出现的现象，并分析其原因。

实验代码如下：

# include<stdio.h> 
# include<signal.h> 
# include<unistd.h> 
# include<stdlib.h>int pid1,pid2;
int EndFlag=0;void IntDelete() 
{ kill(pid1,10); kill(pid2,12); EndFlag=1; 
} 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); 
} int main() 
{ int exitcode; signal(SIGINT,SIG_IGN); signal(SIGQUIT,SIG_IGN); while((pid1=fork())==-1); if(pid1==0) {  signal(10,Int1); signal(SIGQUIT,SIG_IGN); pause(); exit(0); } else { while((pid2=fork())==-1); if(pid2==0) { signal(12,Int2); signal(SIGQUIT,SIG_IGN); pause(); exit(0); } else { signal(SIGINT,IntDelete); waitpid(-1,&exitcode,0); printf("parent process is killed \n"); exit(0); }  }
}

运行上述代码，我们得到以下结果：

Q：运行程序并分析结果。

在子进程产生之前，父进程通过 SIG_IGN 状态字，实现了对于 SIGINT, SIGQUIT 两个信号的屏蔽。当父进程产生了两个子进程之后，父进程的屏蔽传入子进程中，而后父进程将信号函数覆盖为 signal(SIGINT,IntDelete)，在接收到软中断信号后，父进程调用 kill()，向子进程发送信号，子进程接收到信号后，完成退出。

2.3 题目

编程用 fork() 创建一个子进程代表售票员，司机在父进程中，再用系统调用 signal() 让父进程（司机）捕捉来自子进程（售票员）发出的中断信号，让子进程（售票员）捕捉来自（司机）发出的中断信号，以实现进程间的同步运行。

我们根据题意，编写以下代码：

# include<stdio.h> 
# include<signal.h> 
# include<unistd.h> 
# include<stdlib.h>int pid;void IntDelete() 
{ printf("conductor sent the signal!\n");kill(pid,10); 
}void Int() 
{ printf("seller received the signal!\n"); printf("child process is killed\n");exit(0); 
} int main() 
{ int exitcode; signal(SIGINT,SIG_IGN); signal(SIGQUIT,SIG_IGN); while((pid=fork())==-1); if(pid==0){  signal(10,Int); signal(SIGQUIT,SIG_IGN);pause();exit(0);} else { signal(SIGINT,IntDelete); waitpid(-1,&exitcode,0); printf("parent process is killed\n");exit(0);  }
}

运行结果如下：

由此可见已达成实验要求。

实验思考

Q：系统是怎样创建进程的？

系统创建进程大致可以分为以下四步：

1. 申请空白PCB
2. 为新进程分配资源
3. 初始化进程控制块（初始化标识信息、初始化处理机状态信息、初始化处理机控制信息）
4. 将新进程插入就绪队列

Q：当首次调用新创建进程时，其入口在哪里？

进程的进程控制块（PCB）结构中有指向其TTS（任务状态段）的指针，TTS里面存放着进程的入口。编程实践中入口为 fork() 函数

Q：当前运行的程序（主进程）的父进程是什么？

当前运行程序的父进程是应该是该进程的上一个进程，在 Linux中所有进程都起源 systemd 进程：