操作系统实验报告进程的创建

合集下载

操作系统实验报告--进程的创建

操作系统实验报告--进程的创建
else
{
printf("父进程id=%d,父进程打印a\n",getpid());
exit(0);
}
}
随机执行:
程序执行如下:
1.父进程里的fork调用,复制父进程生成一个副本即为子进程1
2.得到父进程与子进程1
3.随机执行这两进程中的一个,(两个进程都是压在栈里)
4.假设(那么栈底下的就是父进程)执行的是子进程1,则fork返回值是0,则for循环中断!这是也是子进程不能创建自己的子子进程的一个重点!i=0,往下继续执行当前进程的后面的程序,打印当前子进程1的信息,并且按照要求打印出b。这个进程执行完毕后自动销毁!
printf("\n开始调用fork函数:\n如果调用成功应该会生成一个子进程1\n返回值: 若成功调用一次则返回两个值,\n子进程返回0,父进程返回子进程标记(ID);\n否则,出错返回-1。\n");
fpid1=fork();
fpid2=fork();
if(fpid1<0)exit(0);
else if(fpid1>0)
{
break;
}
}
if(pid==-1)
{
perror("fail to fork!\n");
exit(1);
}
else if(pid==0)
{
printf("子进程%did=%d,打印%c,其对应的父进程id=%d\n",i+1,getpid(),98+i,getppid());
exit(0);
}
源代码:
#include<stdio.h>
#include<unistd.h>

进程的创建实验报告

进程的创建实验报告

进程的创建实验报告进程的创建实验报告引言:在计算机科学领域中,进程是一个非常重要的概念。

进程是计算机程序的执行实例,它具有独立的内存空间和执行环境。

进程的创建是操作系统中一个关键的操作,本实验旨在通过编写一个简单的程序来演示进程的创建过程。

实验目的:通过实验,我们的目标是深入理解进程的创建过程,并了解操作系统是如何管理进程的。

实验步骤:1. 引入必要的头文件:在开始编写代码之前,我们需要引入一些必要的头文件。

这些头文件包括<sys/types.h>、<sys/wait.h>和<unistd.h>。

这些头文件提供了创建进程所需的函数和数据类型。

2. 创建一个子进程:在主程序中,我们使用fork()函数来创建一个子进程。

fork()函数会在当前进程的基础上创建一个新的进程,这个新进程称为子进程。

子进程和父进程几乎完全相同,只有在返回值上有所区别。

如果fork()函数返回0,表示当前进程是子进程;如果返回一个正整数,表示当前进程是父进程。

3. 子进程的执行:在子进程中,我们可以编写任意的代码来执行特定的任务。

子进程可以使用exec()函数来执行其他程序,或者执行一系列的操作。

在本实验中,我们简单地输出一条信息,以展示子进程的执行过程。

4. 父进程的执行:在父进程中,我们可以编写代码来执行其他任务,或者等待子进程的结束。

在本实验中,我们使用wait()函数来等待子进程的结束。

wait()函数会暂停父进程的执行,直到子进程结束为止。

5. 编译和运行程序:在完成代码编写后,我们需要将程序编译成可执行文件,并运行它。

我们可以使用gcc编译器来编译程序,然后运行生成的可执行文件。

实验结果:在运行程序后,我们可以观察到以下结果:子进程开始执行。

父进程等待子进程结束。

子进程结束。

父进程继续执行。

结论:通过本实验,我们成功地演示了进程的创建过程。

我们了解了操作系统是如何管理进程,并且掌握了使用fork()函数来创建子进程的方法。

操作系统实验实验报告

操作系统实验实验报告

操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件,它管理着计算机的硬件资源和软件资源,为用户提供了一个方便、高效、稳定的工作环境。

本次操作系统实验的目的在于通过实际操作和实践,深入理解操作系统的基本原理和核心概念,掌握操作系统的基本功能和操作方法,提高对操作系统的认识和应用能力。

二、实验环境本次实验使用的操作系统为 Windows 10 专业版,开发工具为Visual Studio 2019,编程语言为 C 和 C++。

实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。

三、实验内容(一)进程管理实验1、进程创建与终止通过编程实现创建新的进程,并在完成任务后终止进程。

在实验中,我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。

通过观察进程的创建和终止过程,深入理解了进程的生命周期和状态转换。

2、进程同步与互斥为了实现进程之间的同步与互斥,我们使用了信号量、互斥量等同步对象。

通过编写多线程程序,模拟了多个进程对共享资源的访问,实现了对共享资源的互斥访问和同步操作。

在实验中,我们深刻体会到了进程同步与互斥的重要性,以及不正确的同步操作可能导致的死锁等问题。

(二)内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。

通过实验,了解了内存分配的不同方式(如堆分配、栈分配等)以及内存释放的时机和方法,掌握了内存管理的基本原理和操作技巧。

2、内存分页与分段通过编程模拟内存的分页和分段管理机制,了解了内存分页和分段的基本原理和实现方法。

在实验中,我们实现了简单的内存分页和分段算法,对内存的地址转换和页面置换等过程有了更深入的理解。

(三)文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。

操作系统实验二实验报告

操作系统实验二实验报告

操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术,包括进程的创建、执行、同步和通信。

通过实际编程和实验操作,提高对操作系统原理的认识,培养解决实际问题的能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程环境为 Visual Studio 2019。

三、实验内容及步骤(一)进程创建实验1、首先,创建一个新的 C++项目。

2、在项目中,使用 Windows API 函数`CreateProcess`来创建一个新的进程。

3、为新进程指定可执行文件的路径、命令行参数、进程属性等。

4、编写代码来等待新进程的结束,并获取其退出代码。

(二)进程同步实验1、设计一个生产者消费者问题的模型。

2、使用信号量来实现生产者和消费者进程之间的同步。

3、生产者进程不断生成数据并放入共享缓冲区,当缓冲区已满时等待。

4、消费者进程从共享缓冲区中取出数据进行处理,当缓冲区为空时等待。

(三)进程通信实验1、选择使用管道来实现进程之间的通信。

2、创建一个匿名管道,父进程和子进程分别读写管道的两端。

3、父进程向管道写入数据,子进程从管道读取数据并进行处理。

四、实验结果及分析(一)进程创建实验结果成功创建了新的进程,并能够获取到其退出代码。

通过观察进程的创建和执行过程,加深了对进程概念的理解。

(二)进程同步实验结果通过使用信号量,生产者和消费者进程能够正确地进行同步,避免了缓冲区的溢出和数据的丢失。

分析结果表明,信号量机制有效地解决了进程之间的资源竞争和协调问题。

(三)进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。

数据能够准确地在进程之间传递,验证了管道通信的有效性。

五、遇到的问题及解决方法(一)在进程创建实验中,遇到了参数设置不正确导致进程创建失败的问题。

通过仔细查阅文档和调试,最终正确设置了参数,成功创建了进程。

(二)在进程同步实验中,出现了信号量使用不当导致死锁的情况。

电大操作系统实验报告3_ 进程管理实验

电大操作系统实验报告3_ 进程管理实验

电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一,本次实验的目的是通过实际操作和观察,深入理解进程的概念、状态转换、进程调度以及进程间的通信机制,掌握操作系统中进程管理的基本原理和方法,提高对操作系统的整体认识和实践能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C 语言,开发工具为 Visual Studio 2019。

三、实验内容及步骤(一)进程的创建与终止1、编写一个 C 程序,使用系统调用创建一个子进程。

2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。

3、子进程执行一段简单的计算任务,父进程等待子进程结束后输出结束信息。

以下是实现上述功能的 C 程序代码:```cinclude <stdioh>include <stdlibh>include <unistdh>int main(){pid_t pid;pid = fork();if (pid < 0) {printf("创建子进程失败\n");return 1;} else if (pid == 0) {printf("子进程:我的进程 ID 是%d,父进程 ID 是%d\n",getpid(), getppid());int result = 2 + 3;printf("子进程计算结果:2 + 3 =%d\n", result);exit(0);} else {printf("父进程:我的进程 ID 是%d,子进程 ID 是%d\n",getpid(), pid);wait(NULL);printf("子进程已结束\n");}return 0;}```编译并运行上述程序,可以观察到父进程和子进程的输出信息,验证了进程的创建和终止过程。

(二)进程的状态转换1、编写一个 C 程序,创建一个子进程,子进程进入睡眠状态一段时间,然后被唤醒并输出状态转换信息。

操作系统进程的创建实验报告

操作系统进程的创建实验报告
分析showdetail()函数流程图如下:
分析main()函数流程图如下:
三、.思考题
1)进程创建的核心内容是什么?
答:内容是:1、申请空白PCB 2、为新进程分配资源
3、初始化进程控制块4、将新进程插入到就绪队列
2)该设计和实际的操作系统进程创建相比,缺少了哪些步骤?
答缺少的步骤有:只是模拟的创建,并没有分配资源
只是模拟的创建并没有分配资源四实验总结通过本次实验让我对进程的创建有更深的理解是我真真切切的理解到进程和程序的本质区别
一、实验内容
树形图1:
树形图1分析:进程1、2、3是根进程的子进程,相反的根进程是进程1、2、3的父进程,他们分别对应的优先级为2、2、2;接下来进程4、5又是进程1的子进程,进程6、7是进程2的子进程,进程8是进程3的子进程。
四、实验总结
通过本次实验,让我对进程的创建有更深的理解,是我真真切切的理解到进程和程序的本质区别。学会了如何使用基本命令进行调试和运行程序。总之这让我受益非浅。
各个方面都很符合要求,完成很好,体会写得很深入,继续努力ing。
输入如下:
createpc(1,0,2)
createpc(2,0,2)
createpc(3,0,2)
createpc(4,2,3)
createpc(5,2,3)
createpc(6,2,3)
createpc(7,5,3)
createpc(8,5,3)
运行截图如下:
二、函数分析:
分析createpc(para)函数流程图如下:
输入如下:
createpc(1,0,2)
createpc(2,0,2)
createpc(3,0,2)
createpc(4,0,2)

进程创建实验报告

进程创建实验报告

进程创建实验报告进程创建实验报告引言:进程是计算机系统中的基本概念之一,也是操作系统的核心概念之一。

进程创建是操作系统中的一个重要操作,它涉及到资源的分配和管理,对于操作系统的正常运行具有重要意义。

本实验旨在通过编写一个简单的程序,探索进程创建的过程以及相关概念。

一、实验目的本实验的主要目的是了解进程创建的基本过程,并掌握相关的概念和操作。

通过实践,加深对操作系统的理解和应用。

二、实验环境本实验使用的是Linux操作系统,具体的版本为Ubuntu 20.04 LTS。

在该环境下,我们可以使用C语言编写程序,并通过gcc编译器进行编译和运行。

三、实验步骤1. 编写源代码首先,我们需要编写一个简单的C语言程序,用于创建一个新的进程。

在程序中,我们可以使用fork()函数来创建新的进程。

具体的代码如下:```c#include <stdio.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("Failed to create a new process.\n");} else if (pid == 0) {printf("This is the child process.\n");} else {printf("This is the parent process.\n");}return 0;}```2. 编译和运行程序在终端中,使用gcc编译器将源代码编译为可执行文件。

具体的命令如下:```shellgcc -o process_create process_create.c```编译成功后,我们可以通过运行可执行文件来创建新的进程。

具体的命令如下:```shell./process_create```3. 观察输出结果运行程序后,我们可以观察到输出结果。

进程的建立实验报告(3篇)

进程的建立实验报告(3篇)

第1篇一、实验背景与目的在操作系统中,进程是执行程序的基本单位。

进程的建立是操作系统管理进程的第一步,也是理解进程生命周期的基础。

本实验旨在通过实践操作,让学生了解进程的创建过程,掌握创建进程的方法,并理解进程间的关系。

二、实验环境- 操作系统:Linux- 编程语言:C语言- 工具:gcc编译器、gdb调试器三、实验内容1. 理解进程创建的基本概念- 进程:是具有一定独立功能的程序关于某个数据集合上的一次运行活动,是系统进行资源分配和调度的一个独立单位。

- 进程的五个基本状态:创建态、就绪态、运行态、阻塞态、终止态。

2. 创建进程- 使用`fork()`系统调用创建进程。

- `fork()`系统调用:用于创建一个新的进程,即子进程。

子进程是父进程的一个副本,具有相同的内存空间和执行代码。

- 父进程和子进程的关系:父进程通过`fork()`系统调用返回值区分子进程和父进程。

如果返回值为0,则表示当前进程是子进程;如果返回值大于0,则表示当前进程是父进程,返回值是子进程的进程标识符。

3. 进程间通信- 使用管道(pipe)实现进程间通信。

- 管道是一种特殊的文件,用于实现进程间的数据传递。

4. 进程同步- 使用互斥锁(mutex)和条件变量(condition variable)实现进程同步。

- 互斥锁:用于保证在同一时刻只有一个进程可以访问共享资源。

- 条件变量:用于实现进程间的条件等待和通知。

四、实验步骤1. 编写C语言程序,使用`fork()`系统调用创建子进程。

2. 在父进程中,使用管道(pipe)创建一个管道,用于与子进程进行通信。

3. 在父进程中,通过管道向子进程发送数据。

4. 在子进程中,从管道接收数据,并处理数据。

5. 使用互斥锁和条件变量实现进程同步。

五、实验结果与分析1. 父进程和子进程成功创建。

2. 数据通过管道成功传递。

3. 进程间同步成功实现。

六、实验总结通过本次实验,我们了解了进程的创建过程,掌握了创建进程的方法,并理解了进程间的关系。

操作系统:进程创建与撤消

操作系统:进程创建与撤消

操作系统实验报告试验一:进程创建与撤销计科112康岩岩2011008142202013/4/10实验一:进程创建与撤消一、实验目的1、加深对进程概念的理解和进程创建与撤消算法;2、进一步认识并发执行的实质。

二、实验内容本实验完成如下三个层次的任务:(1)系统级—以普通用户身份认识windows的进程管理。

通过windows的“任务管理器”观察进程的状态,进行进程的创建、切换和撤销。

(2)语言级—以普通程序员身份认识高级语言VC++/Java/C#的进程创建与撤销工具。

(3)模拟级—以OS设计师身份编程模拟实现进程创建与撤销功能,并在屏幕上观察进程活动的结果。

三、实验步骤1、windows的进程管理以下是win7的人物管理器,可以进行进程的查看、创建、撤销等操作,由于操作比较简单与琐碎,这里不再具体描述。

2、VC++/Java/C#的进程创建与撤销工具对于本次试验,我使用C#进行进程创建、撤销等测试,具体内容在下面给出。

3、进程创建与撤销的模拟实现(1)总体设计:此次程序完全由c#实现,能够通过窗体界面详细地生动地显示进程的运行状态。

下面一步一步的进行实现①数据定义:类PCB的定义如下:class PCB{string pcbName; //进程名int pcbId; //IDlong startTime; //开始时间long pcbRuntime = 0; //运行时间int pcbLeve; //线程优先级}对于所有的进程信息,用以下表储存:Dictionary<int,Hashtable>ThreadTable=new Dictionary<int,Hashtable>();容器ThreadTable用来储存所有进程简直key 表示进程id,值为Hashtable,储存的为线程信息,②函数CREATE(PCB pcb)—进程创建:创建进程需要传入一个PCB 对象,然后启动一个单独的线程来操作该对象,操作该对象就是把线程运行的状态传送给PCB同时PCB也唯一地标示其所在的线程。

操作系统实验三-进程的创建

操作系统实验三-进程的创建

操作系统实验三-进程的创建(总13页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--操作系统实验报告哈尔滨工程大学软件学院第一讲实验环境的使用一、实验概述1. 实验名称进程的创建2. 实验目的练习使用EOS API函数 CreateProcess创建一个进程,掌握创建进程的方法,理解进程和程序的区别。

调试跟踪 CreateProcess函数的执行过程,了解进程的创建过程,理解进程是资源分配的单位。

3. 实验类型(验证、设计)验证4. 实验内容二、实验环境操作系统:windows xp编译环境:OS Lab语言:汇编语言、C语言三、实验过程(每次实验不一定下面6条都写,根据实际情况定)1.设计思路和流程图main函数流程图2. 需要解决的问题及解答(1)在源代码文件提供的源代码基础上进行修改,要求使用同时创建10个进程。

提示:可以使用PROCESS_INFORMATION类型定义一个有10个元素的数组,每一个元素对应一个进程。

使用一个循环创建10个子进程,然后再使用一个循环等待10个子进程结束,得到退出码后关闭句柄。

答:后文中,有此题解决方案。

尝试根据之前对PsCreateProcess函数和PspCreateProcessEnvironment 函数执行过程的跟踪调试,绘制一幅进程创建过程的流程图。

PspCreateThread创建了进程的主线程结束(3)在PsCreateProcess函数中调用了PspCreateProcessEnvironment函数后又先后调用了PspLoadProcessImage和PspCreateThread函数,学习这些函数的主要功能。

能够交换这些函数被调用的顺序吗思考其中的原因。

答:PspCreateProcessEnvironment 的主要功能是创建进程控制块并且为进程创建了地址空间和分配了句柄表。

PspLoadProcessImage是将进程的可执行映像加载到了进程的地址空间中。

操作系统实验三实验报告

操作系统实验三实验报告
三、实验内容
(一)进程创建
编写程序实现创建多个进程,并观察进程的执行情况。通过调用Windows API函数`CreateProcess`来创建新的进程。在创建进程时,设置不同的参数,如进程的优先级、命令行参数等,观察这些参数对进程执行的影响。
(二)进程控制
实现对进程的暂停、恢复和终止操作。使用`SuspendThread`和`ResumeThread`函数来暂停和恢复进程中的线程,使用`TerminateProcess`函数来终止进程。通过控制进程的执行状态,观察系统的资源使用情况和进程的响应。
(一)进程创建实验结果与分析
创建多个进程后,通过任务管理器观察到新创建的进程在系统中运行。不同的进程优先级设置对进程的CPU占用和响应时间产生了明显的影响。高优先级的进程能够更快地获得CPU资源,执行速度相对较快;而低优先级的进程则在CPU资源竞争中处于劣势,可能会出现短暂的卡顿或计一个多进程同步的程序,使用信号量、互斥量等同步机制来协调多个进程的执行。例如,实现一个生产者消费者问题,多个生产者进程和消费者进程通过共享缓冲区进行数据交换,使用同步机制来保证数据的一致性和正确性。
四、实验步骤
(一)进程创建实验步骤
1、打开Visual Studio 2019,创建一个新的C++控制台应用程序项目。
六、实验中遇到的问题及解决方法
(一)进程创建失败
在创建进程时,可能会由于参数设置不正确或系统资源不足等原因导致创建失败。通过仔细检查参数的设置,确保命令行参数、环境变量等的正确性,并释放不必要的系统资源,解决了创建失败的问题。
(二)线程控制异常
在暂停和恢复线程时,可能会出现线程状态不一致或死锁等异常情况。通过合理的线程同步和错误处理机制,避免了这些异常的发生。在代码中添加了对线程状态的判断和异常处理的代码,保证了线程控制的稳定性和可靠性。

《操作系统》课程实验报告

《操作系统》课程实验报告

《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察,深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念,并掌握相关的操作技能和分析方法。

二、实验环境1、操作系统:Windows 10 专业版2、开发工具:Visual Studio Code3、编程语言:C/C++三、实验内容(一)进程管理实验1、进程创建与终止通过编程实现创建新进程,并观察进程的创建过程和资源分配情况。

同时,实现进程的正常终止和异常终止,并分析其对系统的影响。

2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。

通过模拟多个进程对共享资源的访问,观察并解决可能出现的竞争条件和死锁问题。

(二)内存管理实验1、内存分配与回收实现不同的内存分配算法,如首次适应算法、最佳适应算法和最坏适应算法。

观察在不同的内存请求序列下,内存的分配和回收情况,并分析算法的性能和优缺点。

2、虚拟内存管理研究虚拟内存的工作原理,通过设置页面大小、页表结构等参数,观察页面的换入换出过程,以及对系统性能的影响。

(三)文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。

观察文件在磁盘上的存储方式和文件系统的目录结构。

2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等,通过对大量文件的读写操作,评估不同优化策略对文件系统性能的提升效果。

四、实验步骤(一)进程管理实验步骤1、进程创建与终止(1)使用 C/C++语言编写程序,调用系统函数创建新进程。

(2)在子进程中执行特定的任务,父进程等待子进程结束,并获取子进程的返回值。

(3)通过设置异常情况,模拟子进程的异常终止,观察父进程的处理方式。

2、进程同步与互斥(1)定义共享资源和相关的信号量或互斥锁。

(2)创建多个进程,模拟对共享资源的并发访问。

(3)在访问共享资源的关键代码段使用同步机制,确保进程之间的正确协作。

(4)观察并分析在不同的并发情况下,系统的运行结果和资源竞争情况。

进程的创建实验报告

进程的创建实验报告

一、实验目的1. 理解进程的概念及其在操作系统中扮演的角色。

2. 掌握在特定编程环境中创建进程的方法。

3. 分析进程创建的过程和机制。

4. 熟悉进程间通信和同步的基本原理。

二、实验环境1. 操作系统:Windows 102. 编程语言:C/C++3. 开发工具:Visual Studio 2019三、实验原理进程是操作系统中执行的基本单元,是系统进行资源分配和调度的基本单位。

在操作系统中,进程的创建是系统调用的过程,通过系统调用,父进程可以创建子进程。

在创建子进程时,子进程将继承父进程的某些属性,如环境变量、打开的文件等。

四、实验步骤1. 创建父进程- 编写一个简单的C/C++程序,使用`fork()`系统调用创建子进程。

2. 创建子进程- 在父进程中,通过`fork()`函数创建子进程。

`fork()`函数返回值有以下几种情况:- 返回0:表示子进程;- 返回子进程的进程ID:表示父进程;- 返回-1:表示创建子进程失败。

3. 父进程和子进程的区分- 通过检查`fork()`的返回值,父进程和子进程可以相互区分。

父进程可以通过返回值获取子进程的进程ID。

4. 父进程和子进程的通信- 使用管道(pipe)实现父进程和子进程之间的通信。

创建管道后,父进程通过管道向子进程发送数据,子进程从管道中读取数据。

5. 父进程和子进程的同步- 使用互斥锁(mutex)和条件变量(condition variable)实现父进程和子进程的同步。

父进程在完成工作后,可以通知子进程继续执行。

五、实验代码```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#include <fcntl.h>int main() {int pipe_fd[2];pid_t pid;// 创建管道if (pipe(pipe_fd) == -1) {perror("pipe");exit(EXIT_FAILURE);}// 创建子进程pid = fork();if (pid == -1) {perror("fork");exit(EXIT_FAILURE);}if (pid == 0) {// 子进程close(pipe_fd[1]); // 关闭管道的写端dup2(pipe_fd[0], STDIN_FILENO); // 将管道的读端复制到标准输入execlp("date", "date", NULL); // 执行date命令} else {// 父进程close(pipe_fd[0]); // 关闭管道的读端write(pipe_fd[1], "Hello, world!\n", 15); // 向管道写入数据close(pipe_fd[1]); // 关闭管道的写端wait(NULL); // 等待子进程结束printf("Child process exited with PID %d\n", pid);}return 0;}```六、实验结果与分析1. 父进程和子进程分别运行`date`命令和输出“Hello, world!”字符串。

进程创建实验报告

进程创建实验报告

进程创建实验报告第一篇:进程创建实验报告实验二进程的创建一、实验目的熟悉进程的创建过程,了解系统调用函数fork()和 execl()。

二、实验内容1、阅读实例代码fork1,并编辑、编译、运行,记录程序的运行结果,尝试给出合理的解释,查阅有关资料,掌握系统调用fork()的用法,返回值的意义。

2、阅读实例代码fork2,并编辑、编译、运行,记录程序的运行结果,尝试给出合理的解释,查阅有关资料,掌握在程序中运行一个操作系统命令和运行一个程序的方法。

3、修改fork2,使之能把运行的命令和程序作为参数传给fork2。

三、设计思想1、程序框架pid =-1 pid = 0 pid > 02、用到的文件系统调用函数 fork()和 execl()四、调试过程1、测试数据设计(1)fork1 命名程序1:编写程序1:编译程序1:运行程序1:(2)fork2 编写程序2:运行程序2:(3)修改fork2 编写修改程序2:修改后的运行结果:2、测试结果分析(1)对于程序1:因为系统调用fork()函数是一次调用两次返回值,而且先生成子进程还是父进程是不确定的,所以第一次执行生成子进程的时候返回的pid = 0,判断pid!=-1,所以输出了I’m the child.I’m the parent.第二次,执行父进程的时候,返回的是子进程的进程号pid > 0,即pid的值仍然不为-1,所以又输出了一次I’m the child.I’m the parent。

(2)对于程序2:第一次调用fork()函数时,由于执行的是子进程还是父进程是随机的,所以第一次对父进程返回的是子进程的进程号(大于0),即pid > 0,所以输出I’m the parent.Program end.当第二次执行子进程时返回值是0,即pid = 0,所以输出I’m the child.并调用了execl()函数,查看了指定路径中的文件。

操作系统实验报告(进程的创建)范文

操作系统实验报告(进程的创建)范文

实验题目进程的创建小组合作否姓名班级学号一、实验目的1、了解进程的创建。

2、了解进程间的调用以及实现。

3、分析进程竞争资源的现象,学习解决互斥的方法。

4、加深对进程概念的理解,认识并发执行的本质。

二.实验环境Windows 系统的计算机一台,安装了Linux虚拟机三、实验内容与步骤1、fork()系统调用的使用例子程序代码:#include<stdio.h>#include<sys/types.h>#include<unistd.h>int glob=3;int main(void){pid_t pid;int loc=3;printf("before fork();glod=%d,loc=%d.\n",glob,loc);if((pid=fork())<0){printf("fork() error. \n");exit(0);}else if(pid==0){glob++;loc--;printf("child process changes glob and loc: \n");}elsewait(0);printf("parent process doesn't change the glob and loc:\n");printf("glob=%d,loc=%d\n",glob,loc);exit(0);}运行结果:2、理解vofork()调用:程序代码:#include<stdio.h>#include<sys/types.h>#include<unistd.h>int glob=3;int main(void){pid_t pid;int loc=3;if((pid=vfork())<0){printf("vfork() error\n");exit(0);}else if(pid==0){glob++;loc--;printf("child process changes the glob and loc\n");exit(0);}elseprintf ("parent process doesn't change the glob and loc\n");printf("glob=%d,val=%d\n",glob,loc);}运行结果:3、给进程指定一个新的运行程序的函数exec().程序代码:printe1.c代码:#include<stdio.h>int main(int argc,char * argv[]){int n;char * * ptr;extern char * * environ;for(n=0;n<argc;n++)printf("argv[%d]:%s\n",n,argv[n]);for(ptr=environ; * ptr!=0;ptr++)printf("%s\n",* ptr);exit(0);}file4.c代码如下:#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>char * env_list[]={"USER=root","PATH=/root/",NULL};int main(){pid_t pid;if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execle("/root/print1","print1","arg1","arg2",(char *)0,env_list)<0) printf("execle error!\n");exit(0);}if((waitpid(pid,NULL,0))<0)printf("WAIT ERROR!\n");exit(0);if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execlp("print1","print1","arg1",(char *)0)<0)printf("execle error!\n");exit(0);}exit(0);}运行结果:4、进程终止函数exit()。

创建进程实验报告

创建进程实验报告

一、实验目的1. 理解进程的概念和特点。

2. 掌握创建进程的方法和步骤。

3. 熟悉进程调度和同步机制。

4. 提高编程能力,增强对操作系统的理解。

二、实验环境1. 操作系统:Windows 102. 开发环境:Visual Studio 20193. 编程语言:C++三、实验原理进程是操作系统中独立运行的基本单位,它具有以下特点:1. 进程是动态的,它有一个从创建到消亡的生命周期。

2. 进程是并行的,多个进程可以在同一时间内执行。

3. 进程是异步的,进程的执行顺序不受其他进程的影响。

4. 进程是独立的,进程之间相互隔离,互不影响。

在操作系统中,创建进程主要有以下几种方法:1. 系统调用:通过系统调用创建进程,如fork()、exec()等。

2. 父进程创建:父进程创建子进程,子进程与父进程共享资源。

3. 进程池:通过进程池管理多个进程,提高系统资源利用率。

进程调度是操作系统核心功能之一,它负责将CPU时间分配给各个进程。

常见的进程调度算法有:1. 先来先服务(FCFS)2. 短作业优先(SJF)3. 优先级调度4. 轮转调度进程同步是保证多个进程在执行过程中协调一致的重要机制,常见的同步机制有:1. 互斥锁(Mutex)2. 信号量(Semaphore)3. 条件变量(Condition Variable)4. 事件(Event)四、实验内容1. 创建进程2. 进程调度3. 进程同步五、实验步骤1. 创建进程(1)编写C++程序,使用fork()系统调用创建子进程。

(2)在父进程中,打印子进程的进程ID(PID)。

(3)在子进程中,打印子进程的进程ID(PID)。

2. 进程调度(1)编写C++程序,实现一个简单的进程调度算法。

(2)在程序中,定义多个进程,并按照进程调度算法分配CPU时间。

(3)观察并分析进程执行顺序。

3. 进程同步(1)编写C++程序,使用互斥锁(Mutex)实现进程同步。

(2)在程序中,定义两个进程,其中一个进程负责打印1-10的数字,另一个进程负责打印11-20的数字。

操作系统实验报告(进程的创建).doc

操作系统实验报告(进程的创建).doc

wait(0);printf("parent process doesn't change the glob and loc:\n");printf("glob=%d,loc=%d\n",glob,loc);exit(0);}运行结果:2、理解vofork()调用:程序代码:#include<stdio.h>#include<sys/types.h>#include<unistd.h>int glob=3;int main(void){pid_t pid;int loc=3;if((pid=vfork())<0){printf("vfork() error\n");exit(0);}else if(pid==0){glob++;loc--;printf("child process changes the glob and loc\n");exit(0);}elseprintf ("parent process doesn't change the glob and loc\n");printf("glob=%d,val=%d\n",glob,loc);}运行结果:3、给进程指定一个新的运行程序的函数exec().程序代码:printe1.c代码:#include<stdio.h>int main(int argc,char * argv[]){int n;char * * ptr;extern char * * environ;for(n=0;n<argc;n++)printf("argv[%d]:%s\n",n,argv[n]);for(ptr=environ; * ptr!=0;ptr++)printf("%s\n",* ptr);exit(0);}file4.c代码如下:#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>char * env_list[]={"USER=root","PATH=/root/",NULL};int main(){pid_t pid;if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execle("/root/print1","print1","arg1","arg2",(char *)0,env_list)<0) printf("execle error!\n");exit(0);}if((waitpid(pid,NULL,0))<0)printf("WAIT ERROR!\n");exit(0);if((pid=fork())<0){printf("fork error!\n");exit(0);}else if(pid==0){if(execlp("print1","print1","arg1",(char *)0)<0)printf("execle error!\n");exit(0);}exit(0);}运行结果:4、进程终止函数exit()。

模拟进程创建实验报告(3篇)

模拟进程创建实验报告(3篇)

第1篇一、实验目的1. 理解进程的概念和进程创建的基本原理。

2. 掌握使用C语言模拟进程创建的方法。

3. 熟悉进程的属性和进程之间的通信机制。

4. 分析实验结果,加深对进程管理的理解。

二、实验环境1. 操作系统:Windows 102. 编程语言:C语言3. 开发环境:Visual Studio 2019三、实验原理进程是计算机中程序执行的基本单位,是操作系统进行资源分配和调度的一个独立单位。

进程创建是操作系统的一个重要功能,它负责为进程分配必要的资源,并建立进程控制块(PCB)。

在模拟进程创建实验中,我们将使用C语言编写程序,模拟进程的创建、运行和销毁过程。

通过模拟进程的创建,我们可以了解进程的基本属性,如进程ID、进程状态、父进程ID等。

四、实验步骤1. 定义进程结构体,包含进程的基本属性,如进程ID、进程状态、父进程ID等。

```ctypedef struct {int pid; // 进程IDint state; // 进程状态int parent_pid; // 父进程ID// 其他属性} Process;```2. 编写进程创建函数,用于创建新进程。

```cProcess create_process(int parent_pid) {Process new_process;new_process.pid = ...; // 分配进程IDnew_process.state = ...; // 设置进程状态 new_process.parent_pid = parent_pid;// 设置其他属性return new_process;}```3. 编写进程运行函数,用于模拟进程的运行过程。

```cvoid run_process(Process p) {// 模拟进程运行过程// ...}```4. 编写进程销毁函数,用于销毁进程。

```cvoid destroy_process(Process p) {// 销毁进程资源// ...}```5. 编写主函数,模拟进程创建、运行和销毁过程。

《操作系统原理》进程的创建与管理实验

《操作系统原理》进程的创建与管理实验

《操作系统原理》进程的创建与管理实验1.目的要求(1)加深对进程概念的理解,明确进程和程序的区别。

(2)深入了解系统如何组织进程、创建进程。

(3)进一步认识如何实现处理器调度。

2.实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。

实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所做工作进行测试。

3.所需实验设施设备PC、windows操作系统4.教学形式及过程演示、学生独立完成5.设计思路(1)该程序是一个简单的时间片轮转调度算法的实现。

(2)首先定义了一个进程控制块(PCB)的结构体,包含进程的名称、到达时间、需要的运行时间、剩余运行时间和当前状态等信息。

然后定义了一个创建新节点的函数createNode,用于动态分配内存并初始化节点的数据。

接着定义了一个向循环链表中插入新节点的函数insertNodes,根据用户的输入创建新节点并插入到链表末尾。

然后定义了一个打印链表的函数printList,用于输出链表中所有节点的信息。

(3)接下来是冒泡排序函数bubbleSort,按照到达时间对链表中的节点进行排序。

然后定义了一个运行函数run,根据时间片大小依次运行进程,直到所有进程都完成运行。

最后在主函数中读取用户输入的进程数量和时间片大小,创建链表并调用run函数进行进程调度。

(4)整体思路是:先创建一个空链表,然后根据用户输入的进程数量,逐个创建新节点并插入到链表末尾。

然后对链表中的节点按照到达时间进行排序。

接着按照时间片大小依次运行进程,直到所有进程都完成运行。

最后输出链表中所有节点的信息。

6.知识原理操作系统通过进程控制块(PCB)来组织和管理进程。

(1)首先,操作系统会为每个进程创建一个PCB,PCB中包含了进程的重要信息,如进程号、进程状态、程序计数器、寄存器值、内存分配情况、打开文件等。

(2)当一个进程被创建时,操作系统会为其分配一个唯一的进程号,并将进程的相关信息填充到PCB中。

操作系统实验报告实验3_1

操作系统实验报告实验3_1

操作系统实验报告实验3_1一、实验目的本次实验的主要目的是深入理解操作系统中进程管理的相关概念和原理,通过实际操作和观察,掌握进程的创建、调度、同步与互斥等关键机制,提高对操作系统内核工作原理的认知和实践能力。

二、实验环境本次实验在装有 Windows 10 操作系统的计算机上进行,使用了Visual Studio 2019 作为开发工具,编程语言为 C++。

三、实验内容与步骤(一)进程创建1、编写一个简单的 C++程序,使用系统调用创建一个新的进程。

2、在父进程和子进程中分别输出不同的信息,以区分它们的执行逻辑。

```cppinclude <iostream>include <windowsh>int main(){DWORD pid;HANDLE hProcess = CreateProcess(NULL, "childexe", NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pid);if (hProcess!= NULL) {std::cout <<"Parent process: Created child process with PID "<< pid << std::endl;WaitForSingleObject(hProcess, INFINITE);CloseHandle(hProcess);} else {std::cerr <<"Failed to create child process" << std::endl;return 1;}return 0;}```(二)进程调度1、设计一个多进程并发执行的程序,通过设置不同的优先级,观察操作系统对进程的调度情况。

2、记录每个进程的执行时间和等待时间,分析调度算法的效果。

```cppinclude <iostream>include <windowsh>DWORD WINAPI ProcessFunction(LPVOID lpParam) {int priority =(int)lpParam;DWORD start = GetTickCount();std::cout <<"Process with priority "<< priority <<"started" << std::endl;for (int i = 0; i < 100000000; i++){//执行一些计算操作}DWORD end = GetTickCount();DWORD executionTime = end start;std::cout <<"Process with priority "<< priority <<" ended Execution time: "<< executionTime <<" ms" << std::endl;return 0;}int main(){HANDLE hThread1, hThread2;int priority1 = 1, priority2 = 2;hThread1 = CreateThread(NULL, 0, ProcessFunction, &priority1, 0, NULL);hThread2 = CreateThread(NULL, 0, ProcessFunction, &priority2, 0, NULL);if (hThread1!= NULL && hThread2!= NULL) {SetThreadPriority(hThread1, THREAD_PRIORITY_LOWEST);SetThreadPriority(hThread2, THREAD_PRIORITY_NORMAL);WaitForSingleObject(hThread1, INFINITE);WaitForSingleObject(hThread2, INFINITE);CloseHandle(hThread1);CloseHandle(hThread2);} else {std::cerr <<"Failed to create threads" << std::endl;return 1;}return 0;}```(三)进程同步与互斥1、实现一个生产者消费者问题的程序,使用信号量来实现进程之间的同步与互斥。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

wait(0);
printf("parent process doesn't change the glob and loc:\n");
printf("glob=%d,loc=%d\n",glob,loc);
exit(0);
}
运行结果:
2、理解vofork()调用:
程序代码:
#include<stdio、h>
#include<sys/types、h>
#include<unistd、h>
int glob=3;
int main(void)
{
pid_t pid;
int loc=3;
if((pid=vfork())<0)
{
printf("vfork() error\n");
exit(0);
}
else if(pid==0)
{
glob++;
loc--;
printf("child process changes the glob and loc\n");
exit(0);
}
else
printf ("parent process doesn't change the glob and loc\n");
printf("glob=%d,val=%d\n",glob,loc);
}
运行结果:
3、给进程指定一个新的运行程序的函数exec()、
程序代码:
printe1、c代码:
#include<stdio、h>
int main(int argc,char * argv[])
{
int n;
char * * ptr;
extern char * * environ;
for(n=0;n<argc;n++)
printf("argv[%d]:%s\n",n,argv[n]);
for(ptr=environ; * ptr!=0;ptr++)
printf("%s\n",* ptr);
exit(0);
}
file4、c代码如下:
#include<stdio、h>
#include<sys/types、h>
#include<unistd、h>
#include<sys/wait、h>
char * env_list[]={"USER=root","PATH=/root/",NULL};
int main()
{
pid_t pid;
if((pid=fork())<0)
{
printf("fork error!\n");
exit(0);
}
else if(pid==0)
{
if(execle("/root/print1","print1","arg1","arg2",(char *)0,env_list)<0) printf("execle error!\n");
exit(0);
}
if((waitpid(pid,NULL,0))<0)
printf("WAIT ERROR!\n");
exit(0);
if((pid=fork())<0)
{
printf("fork error!\n");
exit(0);
}
else if(pid==0)
{
if(execlp("print1","print1","arg1",(char *)0)<0)
printf("execle error!\n");
exit(0);
}
exit(0);
}
运行结果:
4、进程终止函数exit()。

程序代码:
#include<stdio、h>
main()
{
printf("this is a exit system call!! \n");
exit(0);
printf("this sentence never be displayen:\n");
}
#include<stdio、h>
main()
{
printf("this is a _exit_test system call! \n");
printf("content in buffer");
exit(0);
}
运行结果:
5、wait()函数与sleep()函数。

程序代码:
#include<stdio、h>
main()
{
int pid1;
if(pid1=fork())
{
if(fork())
{
printf("parent's context,\n");
printf("parent's waiting the child1 terminate,\n");
wait(0);
printf("parent's waiting the child2 terminate,\n");
wait(0);
printf("parent terminates,\n");
exit(0);
}
else
printf("child2's context,\n");
sleep(5);
printf("child2 terminates,\n");
exit(0);
}
else
{
if(pid1==0)
{
printf("child1's context,\n");
sleep(10);
printf("child1 terminates,\n");
exit(0);
}
}
}
运行结果:
6、编写一段程序,父进程使用fork()创建两个子进程,利用输出函数putchar 父进程显示字符”a”,两个子进程分别显示“b”与“c”。

程序代码:
#include<stdio、h>
#include<sys/types、h>
#include<unistd、h>
int main()
{
int pid;
if(pid=fork())
{
if(fork())
{
printf("parent process is \n");
putchar('A');
printf("\n");
}
else
{
printf("child2 process is \n");
putchar('C');
printf("\n");
}
}
else
{
if(pid==0)
printf("child1 process is \n");
putchar('B');
printf("\n");
}
}
运行结果:
四、实验过程与分析
1、在1例子中,调用正确完成时,给父进程返回的就是被创建子进程标识,给子进程自己返回的就是0;创建失败时,返回给父进程的就是-1。

2、在2例子中,vfork()调用后需要注意两点:
(1)子进程先运行,父进程挂起。

子进程调用exec()或exit()之后。

父进程的执行顺序不再有限制。

(2)子进程在调用exec()或exit()之前。

父进程被激活,就会造成死锁。

3、在6例子中,上述程序就是父进程先创建一个子进程,若成功,再创建另一个子进程,之后三个进程并发执行。

究竟谁先执行,就是随机的。

所以执行结果有多重种。

五、实验总结。

相关文档
最新文档