进程管理实验

最新推荐文章于 2023-10-30 22:26:14 发布

不熬夜君

最新推荐文章于 2023-10-30 22:26:14 发布

阅读量843

点赞数 1

分类专栏：操作系统文章标签： linux 服务器 windows

本文链接：https://blog.csdn.net/weixin_64972949/article/details/130721074

版权

操作系统专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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);
		}
	}
}