操作系统实验： 进程管理

最新推荐文章于 2024-06-24 17:40:38 发布
最新推荐文章于 2024-06-24 17:40:38 发布
阅读量1w 收藏 195
点赞数 25
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50542009/article/details/118255771
版权

一．实验目的：

        1. 加深对进程概念的理解，明确进程与程序的区别。

        2. 进一步理解并发执行的实质。

        3. 分析进程争用系统资源的情况，学习解决进程互斥的方法。

        4. 了解Linux中进程通信的基本方法。

二．实验要求：

        在linux系统上用C语言编写程序，分析程序运行结果及原因，加深对进程管理的理解。

三.  实验内容：

  1. 进程的创建

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

      2. 进程的控制

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

        如果在程序中使用系统调用lockf () 来给每一个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。

      3. （1）编写一段程序，使其现实进程的软中断通信。

        要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：

        Child Processll is Killed by Parent!

        Child Processl2 is Killed by Parent!

        父进程等待两个子进程终止后，输出如下的信息后终止。

        Parent Process is Killed!

        (2)在上面的程序中增加语句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发来的消息。

四．算法描述：

        1. fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。其中返回值为零时创建子进程,从子进程返回的id值；返回值大于0时从父进程返回子进程id值；返回值为一1时，创建失败。

        2. lockf(files,function,size)函数用作锁定文件的某些段或者整个文件，函数中参数定义分别为：

        int lockf(files,function,size)

        int files,function;

        long size;

        其中：files是文件描述符；function是锁定和解锁；1表示锁定，0表示解锁。size是锁定和解锁的字节数，若用0，表示从文件的当前位置到文件尾。

        3.  signal(sig,function)函数：为指定的信号安装一个新的信号处理函数，允许调用进程控制软中断信号的处理。signal的返回值是指向之前的信号处理程序的指针。

五．运行结果与分析：

实验1为进程的创建，使用函数fork创建两个子进程，根据fork函数的返回值判断，如果创建子进程成功，即返回值为零，那么两个子进程分别输出字符“b”和“c”，否则父进程输出字符“a”。程序运行结果如下：

图1 进程的创建结果图1

图2 进程的创建结果图2

图3 进程的创建结果图3

由上图可见，多次运行结果为bac。从进程并发角度来看，输出bac，acb等情况都有可能。因为fork( )创建进程所需要的时间要多于输出一个字符的时间，因此在主进程创建进程2的同时，进程1就输出了“b”，而进程2和主进程的输出次序是随机的，所以会出现上述结果。

实验2为进程的控制，在实验1的基础上，将输出字符改为输出一句话，且每个进程输出三次。

图4 进程的控制结果图1

图5 进程的控制结果图2

由图中看出，多次运行结果的输出顺序不同。由于函数printf( )输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变，但是，由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化，这与打印单字符的结果相同。

调用函数lockf（）将每个进程上锁，实现进程间的互斥，结果图如下所示：

图6 加锁进程的控制结果图1

图7 加锁进程的控制结果图2

将每个进程上锁之后，输出结果与未上锁大致相同，也是随着执行时间不同，输出结果不同。因为在上述程序执行时，不同进程之间不存在共享临界资源，所以，加锁与不加锁效果相同。

实验3为软中断通信，创建子进程后调用signal（）函数，父进程捕捉键盘输入的中断信号，捕捉到后调用kill（）函数向子进程发出信号，然后调用两个wait(0)，等待子进程退出。子进程捕捉到信号即输出信息，然后终止。最后父进程输出信息并退出。程序结果图如下所示：

图8 软中断通信结果图1

在程序中增加忽略中断信号和退出语句，由于忽略了中断与退出信号，所以程序一直保持阻塞状态无法退出。结果图如下所示：

图8 软中断通信结果图2

实验4为进程的管道通信，两个进程通过pipe（）建立一条管道，子进程1和子进程2分别先后在临界区中将信息写入管道。父进程被唤醒两次，并两次从管道中读出写入的数据大小，然后输出子进程的信息。结果图如下所示：

图8 管道通信结果图

六．源程序：

进程的创建：

#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");           //执行父进程
		}
	}
}

进程的控制：

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

软中断通信1：

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

软中断通信2：

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

管道通信：

#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(fd);  
	p1=fork();
	if(p1<0){
		printf("Fork Error!\n");
		exit(-1);
	}
	else if(p1==0){
		lockf(fd[1],0,0);
		sprintf(OutPipe,"Child Process1 is sending message!\n");
		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);
			sprintf(OutPipe,"Child Process2 is sending message!\n");
			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);
		}
	}
}

歌者莫姓胡
关注
操作系统-进程管理实验
12-01
关于操作系统模拟进程管理的实验，包括创建、阻塞、唤醒原语等，以及内存的分配与回收。
进程管理实验（操作系统）
11-28
（1） 进程的创建编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。（2） 进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。（3） 编制一段程序，使其实现进程的软中断通信。要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程调用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent process is killed! 在上面的程序中增加语句signal(SIGINT, SIG_IGN)和 signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。（4） 进程的管道通信编制一段程序，实现进程的管道通信。使用系统调用pipe( )建立一条管道线；两个进程P1和P2分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
操作系统的进程管理（c语言模拟）
热门推荐
best_fiends_zxh的博客
10-12 1万+
今天就更一下，模拟进程管理程序。 #include #include #include #include //#define NULL 0 int shumu=0; //进程的内容结构体 struct node { char a[20]; //int a; // char ch; }; typedef struct node Node; //进程PCB结构体 struc
HNU-2024操作系统实验-Lab2-Hello MiniEuler
最新发布
2403_85944944的博客
06-24 508
1.理解操作系统与硬件的接口方法2.实现一个可打印字符的宏（非系统调用），用于后续的调试和开发 2.通过QEMU导出设备树并转成可读格式 virt.dtb转换后生成的virt.dts中可找到如下内容：由上可以看出，virt机器包含有pl011的设备，该设备的寄存器在0x9000000开始处。pl011实际上是一个UART设备，即串口。可以看到virt选择使用pl011作为标准输出，这是因为与PC不同，大部分嵌入式系统默认情况下并不包含VGA设备。此处定义了pl011设备的基址寄存器地址，以及Da
进程管理的实验性应用例子
weixin_30518397的博客
02-28 167
大致实现以下的应用例子，供交流与参考： （1） 进程的控制 修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。 （2） 编制一段程序，使其实现进程的软中断通信。 要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，...
【操作系统】进程管理（一）—— 进程
haoweixl的博客
10-01 1363
进程控制的主要功能是对系统中的所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态转换等功能。简化理解：反正进程控制就是要实现进程状态转换学习技巧：进程控制会导致进程状态的转换。更新PCB中的信息a. 所有的进程控制原语一定都会修改进程状态标志b. 剥夺当前运行进程的CPU使用权必然需要保存其运行环境c. 某进程开始运行前必然要恢复期运行环境将PCB插入合适的队列分配/回收资源。
操作系统实验：进程管理与同步.zip
06-10
在这个"操作系统实验：进程管理与同步.zip"的压缩包中，我们主要关注的是操作系统中的两个关键概念：进程管理和同步。 首先，我们要理解什么是进程。在操作系统中，进程是程序的一次执行实例，它包括程序代码、数据...
操作系统实验实验进程管理
06-19
操作系统实验中的进程管理是计算机科学中的关键概念，尤其是在Windows环境下。Windows操作系统通过API函数CreateProcess()来创建新的进程，这是所有进程生命周期的起点。CreateProcess()函数包含了多个参数，用于...
浙江理工大学操作系统实验1：熟悉Linux系统与进程管理实验报告
01-28
实验1：熟悉Linux系统与进程管理 熟悉Linux系统，几个基本命令的使用，vi编辑器和gcc编译器，进程管理
操作系统Linux实验报告三：进程管理及进程通信.doc
07-13
操作系统Linux实验报告三：进程管理及进程通信 本实验报告主要关注于Linux操作系统中的进程管理和进程通信，通过一系列实验和实践，旨在加深对进程概念的理解，体会系统进程调度的方法和效果，并了解进程之间的通信...
电大操作系统实验2：进程管理实验.doc
12-22
操作系统实验2的主题是进程管理，主要目标是深入理解进程的概念，包括其动态性和并发性，以及如何创建、终止、控制和查看进程的状态信息。实验基于Linux操作系统，具体使用RedHat Linux 9版本。 首先，实验涉及到`...
操作系统进程管理实验（C语言实现）
02-02
操作系统进程管理实验（C语言实现）
操作系统（实验1进程管理）
09-20
1.基本系统进程 　　Csrss.exe：这是子系统服务器进程，负责控制Windows创建或删除线程以及16位的虚拟DOS环境。 　　System Idle Process：这个进程是作为单线程运行在每个处理器上，并在系统不处理其它线程的时候分派处理器的时间。 　　Smss.exe：这是一个会话管理子系统，负责启动用户会话。 　　Services.exe：系统服务的管理工具。 　　Lsass.exe：本地的安全授权服务。 　　Explorer.exe：资源管理器。 　　Spoolsv.exe：管理缓冲区中的打印和传真作业。 　　Svchost.exe：这个进程要着重说明一下，有不少朋友都有这种错觉：若是在“任务管理器”中看到多个Svchost.exe在运行，就觉得是有病毒了。其实并不一定，系统启动的时候，Svchost.exe将检查注册表中的位置来创建需要加载的服务列表，如果多个Svchost.exe同时运行，则表明当前有多组服务处于活动状态；多个DLL文件正在调用它。 　　至于其它一些附加进程，大多为系统服务，是可以酌情结束运行的。由于其数量众多，我们在此也不便于一一列举。 　　在系统资源紧张的情况下，我们可以选择结束一些附加进程，以增加资源，起到优化系统的作用。在排除基本系统及附加进程后，新增的陌生进程就值得被大家怀疑了。 更多内容请看Windows操作系统安装、系统优化大全、系统安全设置专题，或进入讨论组讨论。
进程管理实验
10-26
电子科技大学操作系统进程管理过程模拟 基于python编写，有问题csdn交流。
进程管理 实验
10-10
最近在上操作系统课，第一个实验进程管理，我网上查了一下，发现别人写的我很不满意，于是自己用C语言写了一个比较满意的程序，嘿嘿，实现了进程的创建，查看正在运行的进程，进程的通信，杀死进程，同时满足在Linux环境下编译
操作系统实验之进程管理
qq_64377514的博客
05-27 3276
新来的进程加到就绪队列末尾。定义PCB类和队列类，利用队列先进先出的特点，实现进程在就绪队列、运行队列、阻塞队列之间的切换，同时状态进行改变。2. 采用“时间片轮转”调度算法对5个进程进行调度，每个进程有一个进程控制块PCB，进程控制块可包含以下信息：进程名、到达时间、需要运行的时间（以时间片为单位）、已用cpu时间（以时间片为单位）、进程状态等等。在阻塞队列里由于进程阻塞，所有未能获得CPU的使用权，当满足一定的条件时，进程状态改变，从阻塞队列中退出，进入就绪队列中等待PCB的调度，如此往复。
linux中fork()函数 举例讲解！
杨
08-30 456
一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事。但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。 一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。 来看看实例： int main() { int i = 0; for(; i < 2; i++) { fork(); pr
操作系统实验：进程管理与控制
"本次实验是关于操作系统中的进程管理，通过编写C语言程序模拟进程队列，涉及进程的创建、查询、阻塞、换出及撤销等操作，加深对进程控制块（PCB）结构和并发执行的理解。" 实验中，进程作为操作系统的基本执行单元...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值