1、实验目的
（1）加深对进程概念的理解，明确进程和程序的区别。
（2）进一步认识并发执行的实质。
（3）分析进程竞争资源现象，学习解决进程互斥的方法。
（4）了解Linux系统中进程通信的基本原理。
2、实验预备内容
在Linux下一个进程在内存里有三部分的数据，就是"代码段"、"堆栈段"和"数据段"。"代码段"，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。
一个程序一旦调用fork函数，系统就为一个新的进程准备了前述三个段，首先，系统让新的进程与旧的进程使用同一个代码段，因为它们的程序还是相同的，对于数据段和堆栈段，系统则复制一份给新的进程，这样，父进程的所有数据都可以留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享任何数据了。
因此，在fork函数执行完毕后，如果创建新进程成功，则出现两个进程，一个是子进程，一个是父进程。在子进程中，fork函数返回0，在父进程中，fork返回新创建子进程的进程ID。我们可以通过fork返回的值来判断当前进程是子进程还是父进程。至于fpid的值为什么在父子进程中不同。“其实就相当于链表，进程形成了链表，父进程的fpid(p 意味point)指向子进程的进程id, 因为子进程没有子进程，所以其fpid为0.
fork（）函数一共有三种返回值：
a）在父进程中，fork返回新创建子进程的进程ID；
b）在子进程中，fork返回0；
c）如果出现错误，fork返回一个负值；
创建新进程成功后，系统中出现两个基本完全相同的进程，这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略。
3、实验内容
（1）进程的创建
编写一段源程序，使系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。试观察纪录屏幕上的显示结果，并分析原因。
（2）进程的控制
修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。
如果在程序中使用调用lockf()来给每一个子进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。
（3）软中断通信
①编写一段程序，使其实现进程的软中断通信。
要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：
Child Processll is Killed by Parent!
Child Processl2 is Killed by Parent!
父进程等待两个子进程终止后，输出如下的信息后终止
Parent Process is Killed!
②在上面的程序中增加语句signal (SIGNAL, SIG-IGN) 和signal (SIGQUIT, SIG-IGN), 观察执行结果，并分析原因。
（4）进程的管道通信
编制一段程序，实现进程的管道通信。
使用系统调用pipe()建立一条管道线；两个子进程P1和P2分别向管道中写一句话：
Child 1 is sending a message!
Child 2 is sending a message!
而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
4、问题思考
（1）系统是怎样创建进程的？
1.申请空白PCB（进程控制块）；
2.为新进程分配资源；
3.初始化PCB；
4.就新进程插入就绪队列；
（2）可执行文件加载时进行了哪些处理？
进程用exec( )装入命令ls ，exec( )后，子进程的代码被ls的代码取代，这时子进程的PC指向ls的第1条语句，开始执行ls的命令代码
（3）当首次调用新创建进程时，其入口在哪里？
ork()函数被调用一次，但返回两次；两次返回区别在于：子程序返回值是0，而父进程返回值是子进程的ID。子进程和父进程运行相同的代码，但是有自己的数据空间。
（4）进程通信有什么特点？
1.管道是一个单向通信信道，如果进程间要进行双向通信，通常需要定义两个管道。
2.管道通过系统调用read(), write()函数进行读写操作。
5.实验步骤，结果与分析
5.1进程创建结果与分析
结果：
分析：从上图我们可以看到， 输出了abc和bac这两种情况，从理论上来讲输出a，b，c这三种字母的任何一种组合都是合理的。输出bac是由于进程创建时间大于输出时间，所以主进程b先输出。而输出abc则是由于在主进程创建进程2的同时，进程1就输出了“b”，而进程2和主进程的输出次序是随机的。
5.2进程控制
不加锁结果：
分析：
由于printf方法不会被中断，所以输出的结果分析其实和输出单字符是一样的 。
加锁结果：
分析：将每个进程上锁之后，输出结果与未上锁大致相同，也是随着执行时间不同，输出结果不同。因为在上述程序执行时，不同进程之间不存在共享临界资源，所以，加锁与不加锁效果相同。这一点如果你认真的理解过实验预备内容就很好理解了！
5.3软中断通信实验
结果1：
分析：
创建子进程后调用signal（）函数，父进程捕捉键盘输入的中断信号，捕捉到后调用kill（）函数向子进程发出信号，然后调用两个wait(0)，等待子进程退出。子进程捕捉到信号即输出信息，然后终止。最后父进程输出信息并退出。
结果2：
分析：
在程序中增加忽略中断信号和退出语句，由于忽略了中断与退出信号，所以程序一直保持阻塞状态无法退出。
5.4 进程间通信
结果：
分析：
两个资进程通过pipe（）建立一条管道，子进程1和子进程2分别先后在临界区中将信息写入管道。父进程被唤醒两次，并两次从管道中读出写入的数据大小，然后输出子进程的信息。
6.源代码
6.1进程创建
#include<unistd.h>
#include<stdio.h>
void main(){
int p1,p2;
while((p1=fork())==-1){} //创建子进程p1
if(p1==0){
printf("b\n");
}
else{
while((p2=fork())==-1){} //创建子进程p2
if(p2==0){
printf("c\n");
}
else{
printf("a\n"); //执行父进程
}
}
}6.2进程控制
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void main() {
int p1, p2, i;
while ((p1 = fork()) == -1) {}
if (p1 == 0) {
for (i = 0; i < 3; i++) {
printf("This is son%d!\n", i);
}
}
else {
while ((p2 = fork()) == -1) {}
if (p2 == 0) {
for (i = 0; i < 3; i++) {
printf("This is daughter%d!\n", i);
}
}
else {
for (i = 0; i < 3; i++) {
printf("This is parent%d!\n", i);
}
}
}
}#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void main() {
int p1, p2, i;
while ((p1 = fork()) == -1) {} //创建子进程p1
if (p1 == 0) {
lockf(1, 1, 0);
for (i = 0; i < 3; i++) {
printf("This is son%d!\n", i);
}
lockf(1, 0, 0);
}
else {
while ((p2 = fork()) == -1) {} //创建子进程p2
if (p2 == 0) {
lockf(1, 1, 0);
for (i = 0; i < 3; i++) {
printf("This is daughter%d!\n", i);
}
lockf(1, 0, 0);
}
else {
lockf(1, 1, 0);
for (i = 0; i < 3; i++) {
printf("This is parent%d!\n", i);
}
lockf(1, 0, 0);
}
}
}6.3软中断通信
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
int w;
void waiting() {
while (w!= 0);
}
void stop() {
w = 0;
}
void main(){
pid_t p1, p2;
p1 = fork();
if (p1 < 0) {
printf("Fork error!\n");
exit(-1);
} else if (p1 == 0) {
w = 1;
signal(SIGINT, stop);
waiting();
printf("Child Process1 is killed by the parent!\n");
exit(0);
} else {
p2 = fork();
if (p2 < 0) {
printf("Fork error!\n");
exit(-1);
} else if (p2 == 0) {
w = 1;
signal(SIGINT, stop);
waiting();
printf("Child Process2 is killed by parent!\n");
exit(0);
} else {
w = 1;
signal(SIGINT, stop);
waiting();
kill(p1, SIGINT);
kill(p2, SIGINT);
waitpid(p1, NULL, 0);
waitpid(p2, NULL, 0);
printf("Parent Process is killed!\n");
exit(0);
}
}
}#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
int w;
void waiting() {
while (w!= 0);
}
void stop() {
w = 0;
}
void main(){
int p1, p2;
signal(SIGINT,SIG_IGN);
signal(SIGQUIT,SIG_IGN);
p1 = fork();
if (p1 < 0) {
printf("Fork error!\n");
exit(-1);
} else if (p1 == 0) {
w = 1;
signal(SIGINT, SIG_IGN);
waiting();
printf("Child Process1 is killed by the parent!\n");
exit(0);
} else {
p2 = fork();
if (p2 < 0) {
printf("Fork error!\n");
exit(-1);
} else if (p2 == 0) {
w = 1;
signal(SIGINT, SIG_IGN);
waiting();
printf("Child Process2 is killed by parent!\n");
exit(0);
} else {
w = 1;
signal(SIGINT, SIG_IGN);
waiting();
kill(p1, SIGINT);
kill(p2, SIGINT);
waitpid(p1, NULL, 0);
waitpid(p2, NULL, 0);
printf("Parent Process is killed!\n");
exit(0);
}
}
}6.4进程间通信
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
int p1,p2;
void main(){
int fd[2];
char OutPipe[100],InPipe[100];
//创建pipe管道
pipe(fd);
p1=fork();
if(p1<0){
printf("Fork Error!\n");
exit(-1);
}
else if(p1==0){
lockf(fd[1],0,0);
//进程1写入数据到OutPiep中
sprintf(OutPipe,"Child Process1 is sending message!\n");
//写入pipe
write(fd[1],OutPipe,50);
sleep(5);
lockf(fd[1],1,0);
exit(0);
}
else{
p2=fork();
if(p2==-1){
printf("Fork Error\n");
exit(-1);
}
else if(p2==0){
lockf(fd[1],1,0);
//进程2写入数据到OutPiep中
sprintf(OutPipe,"Child Process2 is sending message!\n");
//写入pipe
write(fd[1],OutPipe,50);
sleep(5);
lockf(fd[1],1,0);
exit(0);
}
else{
wait(0);
//读出数据
read(fd[0],InPipe,50);
printf("%s\n",InPipe);
wait(0);
//读出数据
read(fd[0],InPipe,50);
printf("%s\n",InPipe);
exit(0);
}
}
}