实验三 Linux进程的创建与控制

合集下载

进程控制实验报告

进程控制实验报告

一、实验目的本次实验旨在通过Linux操作系统的实践操作,加深对进程控制概念的理解。

通过学习进程的创建、调度、同步、通信等基本操作,掌握进程控制的基本方法,并了解进程间通信的机制。

二、实验环境1. 硬件环境:Intel(R) Core(TM) i5-3210M CPU2.50GHz,4.00GB内存。

2. 软件环境:64位Linux操作系统。

三、实验内容1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程间通信四、实验步骤1. 进程的创建与终止(1)使用`fork()`函数创建子进程,通过比较返回值判断创建是否成功。

```cpid_t pid = fork();if (pid < 0) {perror("fork failed");exit(1);}```(2)使用`exit()`函数终止进程。

```cexit(0);```2. 进程的调度与优先级(1)使用`nice()`函数调整进程优先级。

```cnice(10); // 降低进程优先级```(2)使用`priority_seta()`函数设置进程优先级。

```cstruct sched_param param;param.sched_priority = 10;if (sched_setscheduler(pid, SCHED_RR, &param) == -1) { perror("sched_setscheduler failed");exit(1);}```3. 进程同步与互斥(1)使用`semaphore_t`类型的信号量实现进程同步。

```csemaphore_t sem;sem_init(&sem, 0, 1);sem_wait(&sem);// 执行临界区代码sem_post(&sem);sem_destroy(&sem);```(2)使用`mutex_t`类型的互斥锁实现进程互斥。

进程的创建控制-实验报告

进程的创建控制-实验报告

内蒙古师大计算机与信息工程学院《操作系统》课程实验报告操作系统原理实验实习题目进程的创建控制实验指导教师玉柱职称副教授学生姓名王雪婷学号20141105053日期16-12-7实现工具Telnet实现环境Linux通过编写一段程序,使用系统调用fork( ) 函数创建两个子进程,第一个子进程输出 brother1,第二个子进程输出brother2,父进程输出 father,实习内从而体会进程间的并发特征。

容(功能、目标)使用 c 语言进行编写,利用分叉函数生成子进程,子进程生成之后在子进程中调用 sleep( )函数,调整父进程及子进程的并发执行过程。

1. Fork()实(1)功能:创建一子进程;(2)返回值现0:从进程返回;的>0:从父进程返回,返回值为子进程的进程标识号;思想-1:创建失败返回。

、2. Exit()方法(1)功能:终止调用进程(结束进程);和(2)说明:技结束进程后,要通知父进程;术(父进程中 wait 调用读取相应信息)(含3. Wait()数(1)功能:控制父进程与子进程同步;据(2)返回值结-1:出错返回;构、n:正确返回子进程的 ID ;算0:其它。

法) 4. sleep(n)(1)功能:当前进程睡眠n 秒钟;(2)使调用进程进入睡眠队列。

主要代码注释#include<stdio.h>#include<stdlib.h>main(){int p1,p2;while((p1=fork())==-1);// 创建子进程 1if(p1==0)//如果 p1 是 0,执行子进程{ 1 中的内容printf("brother1\n");exit(0);sleep(5);}else//否则将创建子进程2{while((p2=fork())==-1);if(p2==0){printf("brother2\n");exit(0);sleep(0);}wait(0);printf("father\n");}}第一次编写完成之后运行出现了图 1 的情况(因图片放入该页面会出现文字越界现象,所以图片放在了最后一页),经过查找发现程序中使用了exit( ) 函数但是没有使用头文件 <stdlib.h> ;当添加完头文件之后,运行出现了图 2 现象,表明实验成功,但是想起老师上课时说进程上cpu 是随机的,所以测试了四组,但是结果都是一样结果3),输出依次是:brother1 father brother2 .分的(见图析(含实现中出错原因分析)指导教师评语、评分评分:指导教师:年月日图1图2图3。

操作系统实验3进程的创建控制实验

操作系统实验3进程的创建控制实验

操作系统实验3进程的创建控制实验实验三的目标是通过实现一个进程控制程序,来加深我们对进程创建和控制机制的理解,并通过实践来熟悉和掌握相关的编程技巧。

在进行实验之前,我们需要先了解进程的一些基本概念和相关知识。

首先,进程的创建是通过操作系统中的系统调用来完成的。

在Linux系统中,常用的创建进程的系统调用有fork(和exec(。

fork(系统调用可以创建一个新的进程,该进程与调用fork(的进程几乎完全相同;而exec(系统调用则在新创建的进程中执行一个新的程序。

另外,进程的控制机制主要是通过进程的状态来实现的。

进程可以处于就绪状态、运行状态和阻塞状态。

就绪状态的进程可以被调度器选择后立即运行,而阻塞状态的进程则需要等待一些条件满足后才能被唤醒并变为就绪状态。

实验三的具体内容包括:1. 编写一个程序,通过调用fork(创建多个子进程。

子进程和父进程可以并行执行,共享程序的代码和数据段。

2. 子进程通过调用exec(系统调用执行不同的程序。

可以通过调用不同的exec(函数或者传入不同的参数来执行不同的程序。

3. 子进程执行的程序可能会产生不同的结果,比如输出不同的字符串或者产生不同的返回值。

我们可以通过wait(系统调用等待子进程退出,并获取子进程的返回值。

4. 父进程可以通过调用waitpid(系统调用来选择等待一些特定的子进程,以及获取特定子进程的返回值。

通过实验三的实践,我将更加深入地了解进程的创建和控制机制。

实验三的实验结果将让我熟悉和掌握相关的编程技巧,为我今后更加熟练地编写和控制进程打下坚实的基础。

总之,实验三是一个非常有意义的实验,将帮助我更加深入地理解进程的创建和控制机制,并通过实践获得相关的编程技巧。

这将对我今后的学习和实践有很大的帮助。

Linux系统编程之进程控制(进程创建、终止、等待及替换)

Linux系统编程之进程控制(进程创建、终止、等待及替换)

Linux系统编程之进程控制(进程创建、终⽌、等待及替换)进程创建在上⼀节讲解进程概念时,我们提到fork函数是从已经存在的进程中创建⼀个新进程。

那么,系统是如何创建⼀个新进程的呢?这就需要我们更深⼊的剖析fork 函数。

1.1 fork函数的返回值调⽤fork创建进程时,原进程为⽗进程,新进程为⼦进程。

运⾏man fork后,我们可以看到如下信息:#include <unistd.h>pid_t fork(void);fork函数有两个返回值,⼦进程中返回0,⽗进程返回⼦进程pid,如果创建失败则返回-1。

实际上,当我们调⽤fork后,系统内核将会做:分配新的内存块和内核数据结构(如task_struct)给⼦进程将⽗进程的部分数据结构内容拷贝⾄⼦进程添加⼦进程到系统进程列表中fork返回,开始调度1.2 写时拷贝在创建进程的过程中,默认情况下,⽗⼦进程共享代码,但是数据是各⾃私有⼀份的。

如果⽗⼦只需要对数据进⾏读取,那么⼤多数的数据是不需要私有的。

这⾥有三点需要注意:第⼀,为什么⼦进程也会从fork之后开始执⾏?因为⽗⼦进程是共享代码的,在给⼦进程创建PCB时,⼦进程PCB中的⼤多数数据是⽗进程的拷贝,这⾥⾯就包括了程序计数器(PC)。

由于PC中的数据是即将执⾏的下⼀条指令的地址,所以当fork返回之后,⼦进程会和⽗进程⼀样,都执⾏fork之后的代码。

第⼆,创建进程时,⼦进程需要拷贝⽗进程所有的数据吗?⽗进程的数据有很多,但并不是所有的数据都要⽴马使⽤,因此并不是所有的数据都进⾏拷贝。

⼀般情况下,只有当⽗进程或者⼦进程对某些数据进⾏写操作时,操作系统才会从内存中申请内存块,将新的数据拷写⼊申请的内存块中,并且更改页表对应的页表项,这就是写时拷贝。

原理如下图所⽰:第三,为什么数据要各⾃私有?这是因为进程具有独⽴性,每个进程的运⾏不能⼲扰彼此。

1.3 fork函数的⽤法及其调⽤失败的原因fork函数的⽤法:⼀个⽗进程希望复制⾃⼰,通过条件判断,使⽗⼦进程分流同时执⾏不同的代码段。

Linux实验3报告

Linux实验3报告

仲恺农业工程学院实验报告纸(院、系)专业班Linux系统编程课学号姓名实验日期教师评定实验三进程一、实验目的掌握Linux进程创建机制、进程调度原理。

二、实验环境硬件:每个学生需配备计算机一台,操作系统:linux。

三、实验题目和实验内容实验题目:进程实验内容:1、教材174页第1题。

编程,在一个主程序中创建一个子进程,子进程输出“hello world”,然后退出。

2、教材174页第3题。

编程,在程序中使用命令行形式显示程序所在当前文件夹下的内容。

四、实验数据和实验结果(程序运行结果的截图)1、2、五、附录(程序代码)1、代码如下:#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main(){pid_t pid;int vari=5;if((pid=vfork())<0){printf("vfork error.\n");return 1;}else if(pid==0){printf("Hello world! \n");printf("Child process exited!\n");_exit(0);}printf("Parent process exited!\n");return 0;}2、代码如下:#include <stdio.h>#include <sys/types.h>#include <sys/wait.h>#include <stdlib.h>int main(){int status;if((status=system("ls"))<0){printf("system error .\n");exit(0);}return 0;}。

linux的进程管理实验总结

linux的进程管理实验总结

linux的进程管理实验总结Linux的进程管理实验总结1. 引言Linux中的进程管理是操作系统的核心功能之一,在实际的系统运行中起着重要的作用。

进程管理能够有效地分配系统资源、管理进程的运行状态和优先级,以及监控进程的行为。

本文将以Linux的进程管理实验为主题,分步骤介绍实验过程及总结。

2. 实验目的本次实验的目的是理解Linux中进程的概念,掌握进程的创建、运行和终止的基本操作,以及进程的状态转换过程。

3. 实验环境本次实验使用的是Linux操作系统,可以选择使用虚拟机安装Linux或者使用Linux主机进行实验。

4. 实验步骤4.1 进程的创建在Linux中,可以使用系统调用fork()来创建一个新的子进程。

在实验中,可以编写一个简单的C程序来调用fork()系统调用,实现进程的创建。

具体步骤如下:(1)创建一个新的C程序文件,例如"process_create.c"。

(2)在C程序文件中,包含必要的头文件,如<stdio.h>和<unistd.h>。

(3)在C程序文件中,编写main()函数,调用fork()函数进行进程的创建。

(4)编译并运行该C程序文件,观察控制台输出结果。

实验中,可以通过观察控制台输出结果,判断新的子进程是否被成功创建。

4.2 进程的运行在Linux中,通过调用系统调用exec()可以用一个新的程序替换当前进程的执行。

可以使用exec()函数来实现进程的运行。

具体步骤如下:(1)创建一个新的C程序文件,例如"process_run.c"。

(2)在C程序文件中,包含必要的头文件和函数声明,如<stdio.h>和<unistd.h>。

(3)在C程序文件中,编写main()函数,调用execl()函数来执行一个可执行程序。

(4)编译并运行该C程序文件,观察控制台输出结果。

实验中,可以通过观察控制台输出结果,判断新的程序是否被成功执行。

实验三 进程的创建和简单控制

实验三  进程的创建和简单控制

实验三进程的创建和简单控制实验目的:1. 掌握进程的概念和进程的状态,对进程有感性的认识;2. 掌握进程创建方法;3. 认识进程的并发执行,了解进程族之间各种标识及其存在的关系;4. 熟悉进程的创建、阻塞、唤醒、撤销等控制方法。

实验内容:1. 了解有关Linux进程的属性和进程的层次结构;2. 学习有关Linux的前台和后台进程;3. 学习有关Linux命令的顺序执行和并发执行;4. 学习有关挂起和终止进程;5. 了解并发程序的不可确定性,进行简单并发程序设计。

实验步骤:(一)Shell 下的进程控制1. 进入Linux系统。

2. 用ps查看进程。

a) linux的ps命令是用来监视系统进程和资源使用情况的命令,可显示瞬间进程的动态。

b) ps 的参数非常多,常用的参数有:i. -A 列出所有的进程;ii. -w 显示加宽可以显示较多的信息;iii. -au 显示较详细的信息;iv. -aux 显示所有包含其他使用者的进程。

3. 用kill终止某些进程。

a) kill命令通过向进程发送指定的信号来结束进程。

b) 先使用ps查到进程号,再使用kill杀出进程。

4. 用pstree命令显示系统中进程层次结构。

PDF 文件使用 "pdfFactory Pro" 试用版本创建a) pstree指令用ASCII字符显示树状结构,清楚地表达进程间的相互关系。

b) 语法格式pstree [-acGhlnpuUV][-H <程序识别码>][<程序识别码>/<用户名称>](二)Linux 简单进程编程1. 理解系统调用fork()的使用。

a) fork()会产生一个与父程序相同的子程序,唯一不同之处在于其进程号。

图2 系统调用fork()b) 编辑下面的程序,如图3所示,要求实现父进程产生两个子进程,父进程显示字符“a”、两个子进程,分别显示字符“b”、“c”。

LINUX进程创建实验

LINUX进程创建实验

进程创建实验报告一、实验目的1、掌握进程的概念,明确进程的含义;2、认识并了解并发执行的实质。

二、实验准备了解Linux的系统调用函数fork()的用法。

三、实验过程实验一1、编写代码如下:#include <stdio.h>int main(){int p1,p2,p3;while((p1=fork())== -1); /*创建子进程p1*/ if (p1==0)printf("b\n");else{while((p2=fork())== -1); /*创建子进程p2*/if(p2==0)printf("c\n");else{while((p3=fork())==-1); /*创建子进程p3*/if(p3==0)printf("d\n");elseprintf("a\n");}}return 0;}2、创建exe文件在终端中输入上述字符即可将fork.c文件中的程序转化为名为fork的exe文件。

3、执行exe文件将其运行多次后如下:4、结果运行的结果为‘abcd’四个字母任意排列实验二1、编写代码如下#include <stdio.h>main( ){int p1,p2,p3,i;while((p1=fork( ))== -1); /*创建子进程p1*/ if (p1==0)for(i=0;i<10;i++)printf("daughter %d\n",i);else{while((p2=fork( ))== -1); /*创建子进程p2*/ if(p2==0)for(i=0;i<10;i++)printf("son %d\n",i);else{while((p3=fork())== -1); /*创建子进程p3*/ if(p3==0)for(i=0;i<10;i++)printf("son2 %d\n",i);elsefor(i=0;i<10;i++)printf("parent %d\n",i);}}}2、exe文件创建与实验一相同3、执行exe文件4、实验结果结果也是各语句乱序混叠输出。

实验3 Linux进程的创建

实验3   Linux进程的创建

实验3 Linux进程的创建【实验目的】(1)熟悉在c语言源程序中使用linux所提供的系统调用界面的方法。

(2)理解由系统调用创建的子进程的特点。

(3)掌握linux中子进程的创建方法以及调度执行情况,理解进程与程序的区别。

(4)掌握linux提供的c编译器gcc的使用方法。

(5)掌握vi的使用方法。

【实验原理/实验基础知识】一、由系统调用创建的子进程特点:①子进程复制了父进程的数据与堆栈空间,继承父进程的用户代码、组代码、环境变量等等。

②父子映像有各自的存储空间。

③对于父子进程的调度执行具有随机性。

二、Linux中创建子进程的系统调用Linux中创建用户子进程系统调用fork()的使用方法:格式: int fork( )返回值:为0时表示创建成功,从子进程返回;大于0时表示创建成功,从父进程返回,其值为子进程的PID号;等于-1时表示创建失败。

三、Vi的使用方法1.vi的基本概念vi可以分为两种模式,分别是命令模式、插入模式和底行模式,各模式的功能区分如下:1) 命令行模式这是进入vi的默认模式,主要功能是控制屏幕光标的移动,字符、字或行的删除,区段复制。

2) 插入模式主要功能是完成数据、文字的输入,按「ESC」键可回到命令行模式。

3) 底行模式主要功能是设置命令,例如保存文件或退出vi等。

2.vi的基本操作1)进入vi在系统提示符号输入vi及文件名称后,就可以进入vi默认命令行模式。

Vi+回车:newVi+test.c:edit2)切换至插入模式编辑文件进入vi后,按键盘字母i键就可以进入插入模式输入文字或数据。

3)文本修改在插入模式下只能一直输入文字,如果需要修改输入的文字,则按键盘ESC 键返回命令行模式再使用上下键移动光标,再删除文字。

4)退出vi及保存文件按键盘ESC键又插入模式回到命令行模式,输入冒号进入底行模式,继续输入命令。

保存及退出相关命令:: w filename (将文章以指定的文件名filename保存)。

实验三 进程管理-进程的控制实验

实验三 进程管理-进程的控制实验

(1)首先查找调用进程是否有子进程,若无,则返回出错码;(2)若找到一处于“僵死状态”的子进程,则将子进程的执行时间加到父进程的执行时间上,并释放子进程的进程表项;(3)若未找到处于“僵死状态”的子进程,则调用进程便在可被中断的优先级上睡眠,等待其子进程发来软中断信号时被唤醒。

4、exit()终止进程的执行。

系统调用格式:void exit(status)int status;其中,status 是返回给父进程的一个整数,以备查考。

为了及时回收进程所占用的资源并减少父进程的干预,LINUX/LINUX 利用exit( )来实现进程的自我终止,通常父进程在创建子进程时,应在进程的末尾安排一条exit( ),使子进程自我终止。

exit(0)表示进程正常终止,exit(1)表示进程运行有错,异常终止。

如果调用进程在执行exit( )时,其父进程正在等待它的终止,则父进程可立即得到其返回的整数。

核心须为exit( )完成以下操作:(1)关闭软中断(2)回收资源(3)写记帐信息(4)置进程为“僵死状态”参考程序#include<stdio.h>#include<unistd.h>main( ){in t pid;pid=fork( ); /*创建子进程*/switch(pid){case -1:printf("fork fail!\n");exit(1);case 0: /*创建失败*//*子进程*/execl("/bin/ls","ls","­1","­color",NULL); printf("exec fail!\n");exit(1);default:wait(NULL);/*父进程*/ /*同步*/printf("ls completed !\n");exit(0);}}运行结果执行命令ls -l -color ,(按倒序)列出当前目录下所有文件和子目录;ls completed!分析原因程序在调用fork( )建立一个子进程后,马上调用wait( ),使父进程在子进程结束之前,一直处于睡眠状态。

Linux的安装和基本操作命令,进程基本管理,Vi编辑器的应用的实验报告

Linux的安装和基本操作命令,进程基本管理,Vi编辑器的应用的实验报告

Linux的安装和基本操作命令,进程基本管理,Vi编辑器的应用的实验报告C H A N GZ HO U U N I VER S I T Y实验报告实验课程名称: Linux 操作系统学生姓名:学院(系):班级学号:计算机103 指导教师:成绩:实验时间: 2012 年月日 2013 年月日实验一Linux的安装一、实验目的1、了解硬盘分区的概念和方法。

2、掌握硬盘的分区规则。

3、掌握Linux操作系统的安装和配置过程。

二、实验设备1.一台PC机,Red Hat Linux 9.0系统光盘或者ISO文件、VMware 6.0。

三、实验内容和方法1、根据教材所学内容,用光盘或者在虚拟机上安装Red Hat Linux 9.0。

2、自行规划安装Linux操作系统所需的分区结构(注意:完全安装至少要大于5GB空间)。

3、步骤:1)熟悉虚拟机的实用;2)用PQ Magic软件对虚拟机内的硬盘进行分区,格式化;3)安装Linux操作系统;4)安装过程的相关信息设置,并注意文件系统的挂接点;5)安装后的配置操作(显卡声卡显示器等);6)启动安装完成的Linux系统,输入用户名和密码,登录系统。

四、实验报告内容以书面形式记录下每一步的过程(主要过程请用图片给出),包括所输入的若干信息,遇到的问题和解决方法。

五、实验心得通过本次实验,让我了解了硬盘分区的概念和方法,对硬盘的分区规则也有了一定的认识,掌握了Linux 操作系统的安装和配置过程。

实验2 Linux基本操作命令一、实验目的:熟悉Linux的基本命令;熟悉Linux操作系统。

二、预备知识:1、文件操作命令;查看文件命令:ls。

显示文件内容命令:cat。

文件删除命令:rm。

2、目录操作命令改变当前目录的命令:cd;建立一个子目录:mkdir;删除目录命令:rmdir;3、系统管理命令注销命令:logout;关机命令:shutdown。

命令的具体参数和使用方法见实验参考资料。

Linux 进程创建实验报告

Linux 进程创建实验报告

深圳大学实验报告课程名称:Linux系统编程实验项目名称:进程控制和守护进程的创建学院:计算机与软件学院专业:电子信息工程指导教师:冯禹洪报告人:卢国鹏学号:2012130303 班级:电子3班实验时间:实验报告提交时间:教务处制一、实验目标:1.掌握fork()系统调用及进程的相关概念2.掌握wait()和waitpid()系统调用3.掌握进程组,会话进程等概念和setsid()系统调用4.掌握文件重定向的技巧5.掌握创建守护进程的步骤及其实现二、实验环境与工件1.湖边Linux实验室2.Fedora 13三、实验内容与步骤下面的程序会用到如下程序段:从命令行获取数字参数,参考实现见下图:1.编例实现创建n个子进程P1,P2,…,Pn,其中,各进程之间的关系是:P1是调用进程的子进程,P(k+1)是Pk的子进程。

请打印各进程本身的进程号、父进程号,子进程号。

参考运行结果如下。

要求:(1)每个父进程都要等待子进程退出后才能退出;(2)n通过命令行参数传入;(3)附上源代码截图和运行结果截图。

(20分)2.编例实现创建n个子进程P1,P2,…,Pn,其中,各进程之间的关系是:P1,…,Pn都是调用进程的子进程。

请打印各进程本身的进程号、父进程号,子进程号。

参考运行结果如下。

要求:(1)每个父进程都要等待子进程退出后才能退出;(2)n通过命令行参数传入;(3)附上源代码截图和运行结果截图。

(20分)3.编例实现创建n=2d-2个子进程P1,P2,…,Pn,其中,d是树的深度且d>=1,P1和P2是调用进程的子进程,P3和P4是P1的子进程,P5和P6是P2的子进程。

也就是各进程之间的关系是:Pi是P2i+1和P2i+2的父进程,也是组成二叉树的关系,如下图所示。

对于不是叶子的进程,将其ID和父进程ID打印出来。

参考运行结果如下。

要求:(1)每个父进程都要等待子进程退出后才能退出;(2)d通过命令行参数传入;(3)附上源代码截图和运行结果截图。

进程控制 实验报告

进程控制 实验报告

进程控制实验报告进程控制实验报告一、引言进程控制是操作系统中的重要概念,它涉及到进程的创建、调度、终止等方面。

本篇实验报告将介绍我们在进程控制实验中所进行的工作和实验结果。

二、实验目的本次实验的目的是通过编写程序,了解进程的创建、调度和终止过程,并掌握相关的系统调用和操作。

三、实验环境我们使用的实验环境是Linux操作系统,并使用C语言编写程序。

四、实验步骤1. 进程创建在实验中,我们编写了一个简单的程序,用于创建新的进程。

通过调用系统调用fork(),我们可以在父进程中创建一个子进程。

子进程是父进程的副本,它们共享一些资源,但有各自独立的执行空间。

2. 进程调度在实验中,我们使用了系统调用exec()来进行进程调度。

通过调用exec(),我们可以在一个进程中执行另一个可执行文件。

这样,原来的进程将被替换为新的进程,并开始执行新的程序。

3. 进程终止在实验中,我们使用了系统调用exit()来终止一个进程。

当一个进程执行完毕或者遇到错误时,可以调用exit()来结束自己的执行。

同时,exit()函数还可以传递一个整数值作为进程的返回值,供其他进程获取。

五、实验结果通过实验,我们成功地创建了多个进程,并进行了调度和终止操作。

我们观察到,创建的子进程在父进程的基础上执行,并且具有独立的执行空间。

在调度过程中,我们能够看到进程的切换和执行结果的输出。

在终止过程中,我们成功地结束了进程的执行,并获取了进程的返回值。

六、实验总结通过本次实验,我们深入了解了进程控制的相关概念和操作。

我们通过编写程序,实际操作了进程的创建、调度和终止过程。

这些实验结果对于我们理解操作系统的工作原理和进程管理机制具有重要意义。

七、实验感想本次实验让我们深刻认识到进程控制在操作系统中的重要性。

进程的创建、调度和终止是操作系统能够高效运行的基础。

通过实验,我们不仅掌握了相关的系统调用和操作,还加深了对操作系统原理的理解。

八、实验改进在实验中,我们可以进一步扩展功能,例如实现进程间的通信和同步机制。

实验三 进程的创建和简单控制

实验三  进程的创建和简单控制

Linux进程
Linux 内核利用一个数据结构task_struct来代表一个
进程,代表进程的数据结构指针形成了一个 task 数组。
当建立新进程的时候,Linux 为新的进程分配一个 task_struct 结构,然后将指针保存在 task 数组中。 每个在task_struct结构中登记的进程都有相应的进程 状态和进程标志,是进行进程调度的进程调度的两个重要 的数据项。进程在执行了相应的进程调度操作后,会由于 某些原因改变自身的状态和标志,也就是改变state和 flags这两个数据项。进程的状态不同、标志位不同对应 了进程可以执行不同操作。
在后台运行程序
后台运行程序的意思是这个命令继续在内存中执 行,而在这同时shell命令行的控制权已经返回 到了控制台。 对巨型文件进行排序或者对子目录和其他类型 的文件系统进行搜索等等操作都是可以放到后 台去执行的好例子。 运行一个进程命令格式: 进程名 & nohup 进程名 &
报告进程状况 PS
Wait()
#include #include #include #include <sys/types.h> <sys/wait.h> <unistd.h> <stdlib.h>
void main() { pid_t pc,pr; pc = fork(); if(pc < 0) printf("Err\n"); else if (pc == 0) { printf("This is child process with pid of %d\n",getpid()); sleep(10); }else { pr = wait(NULL); //删除此语句后再次运行,观察运行结果的差异。 printf("I catch a child process with pid of %d\n",pr); } exit(0); }

进程的控制_实验报告

进程的控制_实验报告

### 实验目的1. 理解操作系统进程控制的基本概念和原理。

2. 掌握进程的创建、同步、通信和终止等操作。

3. 熟悉Linux系统中的进程控制命令和系统调用。

4. 理解进程调度算法的基本原理和实现方法。

### 实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 编译器:gcc4. 开发工具:vim### 实验内容本实验主要涉及以下内容:1. 进程的创建与终止2. 进程同步与通信3. 进程调度算法#### 1. 进程的创建与终止实验一:利用fork()创建进程```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {printf("Child process, PID: %d\n", getpid()); printf("Child process is running...\n");sleep(2);printf("Child process is exiting...\n");return 0;} else {printf("Parent process, PID: %d\n", getpid()); printf("Parent process is running...\n");sleep(3);printf("Parent process is exiting...\n");wait(NULL);}return 0;}```实验二:利用exec()创建进程```c#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {execlp("ls", "ls", "-l", (char )NULL); printf("execlp() error\n");return 1;} else {wait(NULL);}return 0;}```实验三:进程终止```c#include <stdio.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {printf("Child process, PID: %d\n", getpid()); sleep(2);printf("Child process is exiting...\n");exit(0);} else {wait(NULL);}return 0;}```#### 2. 进程同步与通信实验四:使用信号实现进程同步```c#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>#include <signal.h>int main() {pid_t pid;int status;int signalNo = 1;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {printf("Child process, PID: %d\n", getpid()); while (1) {pause();printf("Child process is running...\n"); }} else {printf("Parent process, PID: %d\n", getpid()); sleep(1);kill(pid, signalNo);wait(NULL);}return 0;}```实验五:使用管道实现进程通信```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {int pipefd[2];pid_t pid;char buffer[100];if (pipe(pipefd) == -1) {printf("pipe() error\n"); return 1;}pid = fork();if (pid < 0) {printf("fork() error\n"); return 1;} else if (pid == 0) {close(pipefd[0]);read(pipefd[1], buffer, sizeof(buffer));printf("Child process, PID: %d, Received: %s\n", getpid(), buffer);} else {close(pipefd[1]);write(pipefd[0], "Hello, Child!\n", 14);wait(NULL);}return 0;}```#### 3. 进程调度算法实验六:先来先服务(FCFS)调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#define NUM_PROCESSES 5#define TIME_QUANTUM 2typedef struct {int pid;int arrival_time;int burst_time;} Process;int main() {Process processes[NUM_PROCESSES] = {{1, 0, 5},{2, 1, 3},{3, 2, 4},{4, 3, 2},{5, 4, 1}};int i, j, time = 0, completed = 0;int wait_time[NUM_PROCESSES], turnaround_time[NUM_PROCESSES]; // Calculate waiting timefor (i = 0; i < NUM_PROCESSES; i++) {wait_time[i] = 0;}for (i = 0; i < NUM_PROCESSES; i++) {for (j = 0; j < i; j++) {wait_time[i] += processes[j].burst_time;}}// Calculate turnaround timefor (i = 0; i < NUM_PROCESSES; i++) {turnaround_time[i] = wait_time[i] + processes[i].burst_time;}// Calculate average waiting time and turnaround timeint total_wait_time = 0, total_turnaround_time = 0;for (i = 0; i < NUM_PROCESSES; i++) {total_wait_time += wait_time[i];total_turnaround_time += turnaround_time[i];}printf("Average waiting time: %.2f\n", (float)total_wait_time / NUM_PROCESSES);printf("Average turnaround time: %.2f\n",(float)total_turnaround_time / NUM_PROCESSES);return 0;}```实验七:时间片轮转调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#define NUM_PROCESSES 5#define TIME_QUANTUM 2typedef struct {int pid;int arrival_time;int burst_time;} Process;int main() {Process processes[NUM_PROCESSES] = {{1, 0, 5},{2, 1, 3},{3, 2, 4},{4, 3, 2},{5, 4, 1}};int i, j, time = 0, completed = 0;int wait_time[NUM_PROCESSES], turnaround_time[NUM_PROCESSES]; // Calculate waiting timefor (i = 0; i < NUM_PROCESSES; i++) {wait_time[i] = 0;}for (i = 0; i < NUM_PROCESSES; i++) {for (j = 0; j < i; j++) {wait_time[i] += processes[j].burst_time;}}// Calculate turnaround timefor (i = 0; i < NUM_PROCESSES; i++) {turnaround_time[i] = wait_time[i] + processes[i].burst_time;}// Calculate average waiting time and turnaround timeint total_wait_time = 0, total_turnaround_time = 0;for (i = 0; i < NUM_PROCESSES; i++) {total_wait_time += wait_time[i];total_turnaround_time += turnaround_time[i];}printf("Average waiting time: %.2f\n", (float)total_wait_time / NUM_PROCESSES);printf("Average turnaround time: %.2f\n",(float)total_turnaround_time / NUM_PROCESSES);return 0;}```### 实验总结通过本次实验,我对操作系统进程控制有了更深入的了解。

进程管理_实验报告

进程管理_实验报告

一、实验目的1. 理解Linux操作系统中进程的概念,明确进程与程序的区别。

2. 掌握Linux下进程的创建、调度、同步与通信等基本操作。

3. 学会使用Linux命令查看和管理进程。

二、实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 开发工具:gcc、gdb三、实验内容1. 进程创建与调度2. 进程同步与互斥3. 进程通信4. 进程控制四、实验步骤1. 进程创建与调度(1)编写一个C程序,创建一个子进程,并在父进程中打印出子进程的进程标识符(PID)。

```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid;pid = fork(); // 创建子进程if (pid == 0) { // 子进程printf("子进程的PID:%d\n", getpid());} else if (pid > 0) { // 父进程printf("父进程的PID:%d,子进程的PID:%d\n", getpid(), pid); } else {printf("创建子进程失败\n");}return 0;}```(2)编译并运行程序,观察结果。

2. 进程同步与互斥(1)编写一个C程序,使用互斥锁(mutex)实现两个进程的同步。

```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 获取互斥锁printf("线程 %ld 获取了互斥锁\n", pthread_self());sleep(1);pthread_mutex_unlock(&mutex); // 释放互斥锁return NULL;}int main() {pthread_t thread1, thread2;pthread_mutex_init(&mutex, NULL); // 初始化互斥锁pthread_create(&thread1, NULL, thread_func, (void )1);pthread_create(&thread2, NULL, thread_func, (void )2);pthread_join(thread1, NULL);pthread_join(thread2, NULL);pthread_mutex_destroy(&mutex); // 销毁互斥锁return 0;}```(2)编译并运行程序,观察结果。

Linux进程创建实验

Linux进程创建实验

Linux进程创建实验目的1.了解有关Linux系统调用;2.学习有关Linux的进程创建,理解进程创建后两个并发进程的执行。

实验内容在Linux环境下,用c语言编程,使用系统调用fork创建进程一个子进程。

观察其运行的结果。

实验提示:LINUX系统调用1. 进程控制的系统调用l fork系统调用创建新的子进程格式:pid=int fork()fork调用返回时,系统中已有两个用户级环境完全相同的进程存在,这两个进程从fork调用中得到的返回值不同,其中子进程得到的返回值为零,父进程得到的返回值是新创建子进程的进程标识号。

l exec系统调用格式:(六种)int execl(path,arg0,arg1,…,argn,(char *)0)char *path, *arg0, *arg1, …, *argn ;exec调用进程的正文段被指定的目标文件的正文段所覆盖,其属性的变化方式与fork成功后从父进程那里继承属性的方式几乎是一样的。

系统中绝大多数命令都是通过exec来执行的,不但shell进程所创建的子进程使用它来执行用户命令,shell进程本身和它的祖先进程也是用exec来启动执行的。

l exit系统调用终止进程执行格式:void exit(status)int status ;参数status是调用进程终止时传递给其父进程的值。

如调用进程还有子进程,则将其所有子进程的父进程改为1号进程。

l wait系统调用等待子进程暂仃或终止格式:int wait(stat_loc) int wait((int *)0)int stat_loc ;wait调用将调用进程挂起,直到该进程收到一个被其捕获的信号或者它的任何一个子进程暂仃或终止为止。

如果wait调用之前已有子进程暂仃或终止,则该调用立即返回。

l lockf 锁定文件格式:int lockf(fd,fuction,size)int files, fuction; long size; fd –锁定文件标识function=0不锁定表示=1锁定=2测试和锁定=3测试有否被锁定size --锁定或解锁的字节数,0表示从文件的当前位置到文件尾。

Linux进程管理编程进程的创建DOC

Linux进程管理编程进程的创建DOC

实训目标:(1)掌握Linux中ps命令使用方法。

(2)掌握Linux中top命令使用方法。

实训内容:(1)使用ps命令查看进程。

(2)使用top命令查看进程。

实训步骤:(1)使用ps命令查看进程。

a.不带参数的ps命令:# psb.带参数的ps命令:# ps aux(2)使用top命令查看进程。

a. 监视特定用户:$ top:输入此命令,按【Enter】键,查看执行结果。

u: 然后输入“u”按【Enter】键,再输入用户名,即可。

b. 终止指定的进程:$ top:输入此命令,按【Enter】键,查看执行结果。

k: 然后输入“k”按【Enter】键,再输入要结束的进程ID 号。

实训2 Linux进程管理编程(进程的创建)实训目标:掌握fork()系统调用的使用。

实训内容:写出如下程序的执行结果,并画出该进程家族树。

/***fork()***/#include<stdio.h>main(){fork(); /*父进程1创建子进程2*/fork(); /*父进程返回后分别再创建各自的子进程3、4*/fork(); /*父进程1、2、3、4返回后分别再创建各自的子进程5、6、7、8*/ putchar(‘A’); /*每个进程都要输出‘A’*/putchar(‘\n’); /*输出‘A’后按【Enter】键换行*/}实训步骤:(1)新建并编辑fork3.c.(2)编译fork3.c。

(3)执行fork3,结果如下。

[cathya@stu 桌面] $ ./fork3AAAAAAAA[cathya@stu 桌面] $(4)查看该进程执行结果为八个“A”,说明有八个进程产生。

其进程关系如图3—8所示。

图3—8 调用三次fork()的进程家族树步骤2—4的执行结果实训3 Linux进程管理编程(父子进程的同步)实训目标:掌握fork()系统调用的使用。

实训内容:实现子进程先输出“B”然后父进程再输出“A”,源程序命名为synl.c。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
for(i=0;i<20;i++)
printf(“child %d\n”,i);
lockf(1,0,0);/解锁/
}
else
{
while((p2=fork())= =-1);
if(p2= =0)
{
lockf(1,1,0);
for(i=0;i<20;i++)
printf(“son %d\n”,i);
lockf(1,0,0);
}
else
{
lockf(1,1,0);
for(i=0;i<20;i++)
printf(“daughter %d\n”,i);
lockf(1,0,0);
}
}
}
思考问题:
(1)系统是怎样创建进程的?
(2)当首次调用新创建进程时,其入口在哪里?
while((p1=fork())= =-1);
if(p1= =0)
for(i=0;i<20;i++)
printf(“Child %d\n”,i);
else
{
while((p2=fork() )= =-1);
if(p2= =0)
for(i=0;i<20;i++)
printf(“Son %d\n”,i)
else
for(i=0;i<20;i++)
printf(“Daughter %d\n”,i);
}
}
程序2:
#include <stdio.h>
#include <unistd.h>
main()
{
intp1,p2,I;
while((p1=fork())= =-1);
if(p1= =0)
{
lockf(1,1,0);/加锁/
1.进程的家族关系
在主程序中用3个fork()调用,最后输出一个字符或字符串,运行此简单的程序,观察并分析运行结果。
2.进程的创建
编写一段源程序,使系统调用fork()创建两个子进程,当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示字符“a”,子进程分别显示字符“b”和字符“c”。观察纪录屏幕上的显示结果,并分析原因。
实验三Linux进程的创建与控制
一、实验目的
(1)加深对进程概念的理解,明确进程和程序的区别。
(2)进一步认识并发执行的实质。
(3)分析进程竞争资源现象,学习解决进程互斥பைடு நூலகம்方法。
(4)了解Linux系统中进程通信的基本原理。
二、实验预备内容
阅读Linux的fork.c源文件,分析进程的创建过程。
三、实验内容
fork();
fork();
printf(“S”);
}
查看运行结果并分析进程的创建和调用过程。
2.进程的创建
#include<stdio.h>
main()
{ int p1,p2;
while((p1=fork())==-1); /创建进程p1,创建成功后退出/
if(p1= =0) /CPU运行p1/
putchar(‘b’);/输出字符b/
else
{
while((p1=fork())==-1); /创建进程p2,创建成功后退出/
if(p1= =0)
putchar(‘c’);
else putchar(‘a’); /父进程执行/
}
}
观察运行结果并分析原因。
3.进程的控制
程序1:
#include<stdio.h>
main()
{
int p1,p2,i;
3. 进程的控制
修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,在观察程序执行时屏幕出现的现象,并分析原因。
如果在程序中使用调用lockf()来给每一个子进程加锁,可以实现进程之间的互斥,观察并分析出现的现象。
四、实验源程序(仅供参考)
1.用进程的家族关系
main()
{
fork();
相关文档
最新文档