实验一进程创建模拟报告

合集下载

操作系统实验报告进程管理

操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。

进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。

本实验报告将介绍进程管理的基本概念、原理和实验结果。

一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。

线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。

进程和线程是操作系统中最基本的执行单位。

2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。

就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。

3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。

常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。

二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。

通过PCB，操作系统可以对进程进行管理和控制。

2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。

进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。

进程的创建和撤销是操作系统中的基本操作之一。

3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。

常见的进程同步与通信机制包括互斥锁、信号量和管道等。

三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。

通过该程序，我们可以观察到不同调度算法对系统性能的影响。

实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。

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

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()。

实验一,进程创建与撤销报告

实验一进程的创建和撤销一、实验目的1、通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解Windows 2000进程生存过程。

2、通过阅读和分析实验程序，学习创建进程、观察进程和终止进程的程序设计方法。

二、背景知识1、创建进程：CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。

下表详细地列出了每个参数的类型和名称。

参数名称使用目的LPCTSTR lpApplivationName 全部或部分地指明包括可执行代码的EXE文件的文件名LPCTSTR lpCommandLine 向可执行文件发送的参数LPSECURIITY_ATTRIBUTES lpProcessAttributes 返回进程句柄的安全属性。

主要指明这一句柄是否应该由其他子进程所继承LPSECURIITY_ATTRIBUTESlpThreadAttributes返回进程的主线程的句柄的安全属性BOOL bInheritHandle 一种标志，告诉系统允许新进程继承创建者进程的句柄DWORD dwCreationFlage 特殊的创建标志 (如CREATE_SUSPENDED) 的位标记LPVOID lpEnvironment 向新进程发送的一套环境变量；如为null 值则发送调用者环境LPCTSTRlpCurrentDirectory新进程的启动目录STARTUPINFO lpStartupInfo STARTUPINFO结构，包括新进程的输入和输出配置的详情LPPROCESS_INFORMATION lpProcessInformation 调用的结果块；发送新应用程序的进程和主线程的句柄和ID可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。

Linux进程管理-实验报告

《Linux 操作系统设计实践》实验一：进程管理实验目的：（1) 加深对进程概念的理解，明确进程和程序的区别。

(2）进一步认识并发执行的实质.（3) 学习通过进程执行新的目标程序的方法。

(4) 了解Linux 系统中进程信号处理的基本原理.实验环境:Red Hat Linux实验内容：(1)进程的创建编写一段程序，使用系统调用fork（）创建两个子进程，当此进程运行时,在系统中有一个父进程和两个子进程活动，让每一个进程在屏幕上显示一个字符，父进程显示字符“a"；子进程分别显示字符“b”和字符“c”，试观察记录屏幕上的显示结果，并分析原因.程序代码:#include<stdio。

h〉int main（）｛int p1 ，p2 ；while（（p1=fork（））==-1)；if（p1==0）putchar（’b'）；else｛while（(p2=fork（））==—1)；if（p2==0）putchar（’c')；elseputchar(’a')；｝return 0；｝运行结果：bca分析:第一个while里调用fork（）函数一次,返回两次。

子进程P1得到的返回值是0,父进程得到的返回值是新子进程的进程ID（正整数)；接下来父进程和子进程P1两个分支运行,判断P1==0,子进程P1符合条件,输出“b”;接下来else里面的while里再调用fork（）函数一次,子进程P2得到的返回值是0，父进程得到的返回值是新子进程的进程ID(正整数）；接下来判断P2==0，子进程P2符合条件,输出“c”,接下来父进程输出“a”，程序结束。

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

程序代码：＃include〈stdio。

h>int main（）｛int p1,p2；while（（p1=fork（））==-1）；if（p1==0）printf("Child1 is running！\n”）;else{while（（p2=fork(））==—1）；if(p2==0)printf（”Child2 is running！\n”）;elseprintf(”Fath er is running！\n”）;｝return 0；｝运行结果:Child1 is running！Child2 is running!Father is running！分析：本实验和上一个实验一样,只是将每个进程输出一个字符改为每个进程输出一句话.第一个while里调用fork（）函数一次，返回两次。

进程管理实验报告_共10篇 .doc

★进程管理实验报告_共10篇范文一：_进程管理实验报告进程管理实验报告一、进程与线程1.实验目的：1.通过本实验学习Linux中创建进程的方法。

2.学习系统调用fork的使用方法。

3.学习系统调用exec族调用的使用方法。

2.实验准备1．进程的创建创建一个进程的系统调用很简单，只要调用fork函数就可以了。

#includepid_tfork()；当一个进程调用了fork以后，系统会创建一个子进程，这个子进程和父进程是不同的地方只有它的进程ID和父进程ID，其他的都一样，就像父进程克隆（clone）自己一样，当然创建两个一模一样的进程是没有意义的，为了区分父进程和子进程，我们必须跟踪fork调用返回值。

当fork调用失败的时候（内存不足或者是用户的最大进程数已到）fork返回—1，否则fork的返回值有重要的作用。

对于父进程fork返回子进程ID，而对于fork 子进程返回0，我们就是根据这个返回值来区分父子进程的。

2.关于fork的说明使用该函数时，该函数被调用一次，但返回两次，两次返回的区别是子进程的返回值是0，而父进程的返回值则是新子进程的进程ID。

将子进程ID返回给父进程的理由是：因为一个进程的子进程可以多于一个，所以没有一个函数可以是一个子进程获得其所有子进程的进程ID。

而fork函数使子进程得到的返回值是0的理由是：一个子进程只会有一个父进程，所以子进程总是可以调用函数getpid获得其父进程的进程ID。

3.系统调用exec族调用的说明父进程创建子进程后，子进程一般要执行不同的程序。

为了调用系统程序，我们可以使用系统调用exec族调用。

Exec族调用有以下五个函数：intexecl(constchar*path,constchar*arg,?);intexeclp(constchar*file,constchar*arg,?);intexecle(constchar*path,constchar*arg,?);intexecv(constchar*path,constchar*argv[]);intexecvp(constchar*file,constchar*argv[]);exec族调用可以执行给定程序。

进程创建实验报告

实验二进程的创建一、实验目的熟悉进程的创建过程，了解系统调用函数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：(2)fork2编写程序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()函数，查看了指定路径中的文件。

（3）对于修改后的程序2：改变了系统调用execl()中参数的文件路径和可执行文件名，即可在程序fork2.c中执行另一个程序wyf.c（但要注意可执行文件名是123）。

实验一进程创建 Linux实验报告

实验一进程创建【实验目的和要求】1、1.了解进程的概念及意义；2.了解子进程和父进程；3.掌握创建进程的方法。

【实验内容】1、1.子进程和父进程的创建；2.编写附件中的程序实例；3.撰写实验报告。

【实验原理】1、原型：#include <unistd.h>pid_t fork(void);在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。

新进程为子进程，而原进程为父进程。

fork函数创建子进程的过程为：使用fork函数得到的子进程是父进程的一个复制品，它从父进程继承了进程的地址空间，包括进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设定、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端，而子进程所独有的只有它的进程号、资源使用和计时器等。

通过这种复制方式创建出子进程后，原有进程和子进程都从函数fork返回，各自继续往下运行，但是原进程的fork返回值与子进程的fork返回值不同，在原进程中，fork返回子进程的pid,而在子进程中，fork返回0,如果fork返回负值，表示创建子进程失败。

子进程和父进程继续执行fork调用之后的指令。

子进程是父进程的副本。

例如，子进程获得父进程数据空间、堆和栈的副本。

注意，这是子进程所有用的副本。

父进程和子进程并不共享这些存储空间部分。

父进程和子进程共享正文段。

2、原型：#include <unistd.h>pid_t vfork(void);vfork函数的调用序列和返回值与fork相同，但两者的语义不同。

vfork函数用于创建一个新进程，而该进程的目的是exec一个新程序。

vfork不将父进程的地址空间完全复制到子进程中，因为子进程会立即调用exec，它在父进程的空间中运行。

vfork保证子进程先运行，在它调用exit之后父进程才可能被调度运行，当子进程调用这两个函数中的任意一个时，父进程会恢复运行。

计算机操作系统综合设计实验报告实验一

计算机操作系统综合设计实验一实验名称：进程创建模拟实现实验类型：验证型实验环境： win7 vc++6.0指导老师：专业班级：姓名：学号：联系电话：实验地点：东六E507 实验日期： 2017 年 10 月 10 日实验报告日期： 2017 年 10 月 10 日实验成绩：一、实验目的1）理解进程创建相关理论；2）掌握进程创建方法；3）掌握进程相关数据结构。

二、实验内容windows 7 Visual C++ 6.0三、实验步骤1、实验内容1)输入给定代码；2)进行功能测试并得出正确结果。

2、实验步骤1）输入代码A、打开 Visual C++ 6.0 ；B、新建 c++ 文件，创建basic.h 头文件，并且创建 main.cpp2）进行功能测试并得出正确结果A 、编译、运行main.cppB、输入测试数据创建10个进程；创建进程树中4层以上的数型结构结构如图所示：。

createpc 创建进程命令。

参数： 1 pid（进程id）、 2 ppid（父进程id）、3 prio（优先级）。

示例：createpc(2,1,2) 。

创建一个进程，其进程号为2，父进程号为1，优先级为23)输入创建进程代码及运行截图4）显示创建的进程3、画出createpc函数程序流程图分析createpc函数的代码，画出如下流程图：四、实验总结1、实验思考(1)进程创建的核心内容是什么？答：1)申请空白PCB 2)为新进程分配资源3)初始化进程控制块 4)将新进程插入到就绪队列（2）该设计和实际的操作系统进程创建相比，缺少了哪些步骤？答:只是模拟的创建，并没有分配资源2、个人总结通过这次课程设计，加深了对操作系统的认识，了解了操作系统中进程创建的过程，对进程创建有了深入的了解，并能够用高级语言进行模拟演示。

一分耕耘，一分收获，这次的课程设计让我受益匪浅。

虽然自己所做的很少也不够完善，但毕竟也是努力的结果。

另外，使我体会最深的是：任何一门知识的掌握，仅靠学习理论知识是远远不够的，要与实际动手操作相结合才能达到功效。

进程创建实验报告

实验名称：进程创建实验实验目的：1. 理解进程的概念和进程创建的过程。

2. 掌握使用系统调用创建进程的方法。

3. 分析进程创建的参数和返回值。

4. 了解进程的层次结构。

实验环境：操作系统：Linux编译器：gcc开发环境：Eclipse/Visual Studio Code实验内容：1. 理论学习- 进程的概念：进程是计算机系统中正在运行的可执行程序实例，具有独立的内存空间、执行状态和系统资源。

- 进程创建：操作系统通过创建一个新的进程来启动一个程序，新的进程会继承父进程的某些属性。

2. 实验步骤（1）编写C语言程序，使用系统调用创建进程。

（2）观察进程的创建过程，分析进程的层次结构。

（3）测试进程创建的参数和返回值。

实验代码：```c#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid;pid = fork(); // 创建子进程if (pid == 0) { // 子进程printf("子进程 %d\n", getpid());exit(0);} else if (pid > 0) { // 父进程printf("父进程 %d, 子进程 %d\n", getpid(), pid);exit(0);} else { // 创建进程失败perror("fork error");exit(1);}return 0;}```实验结果与分析：1. 进程创建过程- 通过`fork()`系统调用创建子进程，返回值分别为子进程ID和0。

父进程的返回值为子进程ID，子进程的返回值为0。

- 在父进程中，打印出父进程和子进程的进程ID，观察到父进程和子进程的进程ID不同。

操作系统进程管理实验报告

操作系统进程管理实验报告一、引言在现代计算机科学中，操作系统的进程管理是确保系统高效运行的关键环节。

本实验旨在通过观察和分析操作系统的进程管理行为，深入理解进程的创建、运行和终止过程，以及操作系统如何对进程进行调度和资源分配。

二、实验目标1、理解进程的基本概念、进程状态及转换。

2、掌握进程的创建、终止和调度方法。

3、观察和分析进程在运行过程中的资源消耗和调度行为。

4、分析操作系统对进程的资源分配和调度策略对系统性能的影响。

三、实验环境与工具本实验在Linux操作系统上进行，使用GNU/Linux环境下的工具进行进程的创建、监控和调度。

四、实验步骤与记录1、创建进程：使用shell命令“fork”创建一个新的进程。

记录下父进程和子进程的PID，以及它们在内存中的状态。

2、进程状态观察：使用“ps”命令查看当前运行进程的状态，包括进程的PID、运行时间、CPU使用率等。

同时，使用“top”命令实时监控系统的CPU、内存等资源的使用情况。

3、进程调度：在“crontab”中设置定时任务，观察系统如何根据预设的调度策略分配CPU资源给各个进程。

4、资源分配：通过修改进程的优先级（使用“nice”命令），观察系统如何调整资源分配策略。

5、终止进程：使用“kill”命令终止一个进程，并观察系统如何处理该进程占用的资源。

五、实验结果与分析1、创建进程：通过“fork”系统调用，成功创建了一个新的进程，并获取了父进程和子进程的PID。

在内存中，父进程和子进程的状态分别为“running”和“ready”。

2、进程状态观察：使用“ps”命令可以看到父进程和子进程的状态均为“running”，同时显示了它们的CPU使用率和运行时间等信息。

通过“top”命令，可以实时监控系统的CPU、内存等资源的使用情况，为进一步分析提供了数据支持。

3、进程调度：在“crontab”中设置定时任务后，系统会根据预设的调度策略以及各个进程的运行状态，动态地分配CPU资源给各个进程。

进程创建实验报告

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

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

操作系统实验报告范文模板

操作系统实验报告范文模板这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和Linu某hell操作。

里面的程序都是我运行过的。

操作系统上机实验报告班级：学号：姓名：实验地点：实验时间：这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和Linu某hell操作。

里面的程序都是我运行过的。

实验一进程的建立【实验目的】创建进程及子进程在父子进程间实现进程通信【实验软硬件环境】Linu某、Window98、Window2000【实验内容】创建进程并显示标识等进程控制块的属性信息；显示父子进程的通信信息和相应的应答信息。

（进程间通信机制任选）【实验程序及分析】编程思路：首先本程序在Linu某用C语言完成的，父子进程的创建用fork函数来实现，然后是父子进程间的通信，这里用pipe实现。

可以定义chan1[2],chan1[2],chan某[0]表示读，chan某[1]表示写。

他们配合使用。

【实验截图】【实验心得体会】通过这次上机练习，我熟悉了用c++实现进程的创建，销毁，父子进程间的通讯等一系列课程中需要学习的内容。

本来进程的概念在一开始我始终无法清晰地理解，但是通过自己用mfc的方法去实现它后，我开始慢慢地理解操作系统的进程的运作机制。

虽然，我只是实现了一个父子进程的创建和通讯，但是，管中窥豹，我想自己开始明白一个操作系统正是由很多这种进程实现功能的。

其中，系统整体的进程调度，管理等等还有很多东西等着我们去进一步学习、理解。

实验二进程间的同步【实验目的】这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和Linu某hell操作。

里面的程序都是我运行过的。

理解进程同步和互斥模型及其应用【实验软硬件环境】Linu某、Window98、Window2000【实验内容】利用通信API实现进程之间的同步：建立司机和售票员进程；并实现他们间的同步运行。

操作系统实验报告

操作系统上机
实验报告
成绩
教师：方敏
2016 年 12月 17日
班级：
学号：140607815
姓名：黄杨
实验地点：E-Ⅲ区208
实验时间：2016.10.13—2016.12.17
实验一创建进程
【实验软硬件环境】
VC
【实验内容】
实验内容：父进程创建一个有名事件，由子进程发送事件信号，父进程获取事件信号后进行相应的处理
实验三信号通信
【实验软硬件环境】
VC++
【实验内容】
父进程创建一个有名事件，由子进程发送事件信号，父进程获取事件信号后进行相应的处理。
【实验程序及分析】
父进程程序：
// Processs.cpp : Defines the entry point for the console application.
return 0;
}
else{
fprintf(fp,"XiDian University");
fclose(fp);
printf("数据已经写入成功\n");
}
FILE *qp;
if((qp = fopen("D:\\Test1\\abc.txt","r"))== NULL){
printf("读文件打开失败！\n");
【实验原理】
父进程创建子进程，实现多个进程并发执行，提高计算机的运行效率。
【实验程序及分析】
试验程序源代码如下：
父进程部分代码：
// test1.cpp : Defines the entry point for the console application.

进程管理实验报告

进程管理实验报告进程管理实验报告引言：进程管理是操作系统中的重要概念，它负责调度和控制计算机系统中的各个进程，确保它们能够有序地执行。

本实验旨在通过实际操作和观察，深入了解进程管理的原理和方法，并通过实验结果分析其影响因素和优化策略。

实验一：进程创建与终止在本实验中，我们首先进行了进程的创建和终止实验。

通过编写简单的程序，我们能够观察到进程的创建和终止过程，并了解到进程控制块（PCB）在其中的作用。

实验结果显示，当一个进程被创建时，操作系统会为其分配一个唯一的进程ID，并为其分配必要的资源，如内存空间、文件描述符等。

同时，操作系统还会为该进程创建一个PCB，用于存储该进程的相关信息，如进程状态、程序计数器等。

当我们手动终止一个进程时，操作系统会释放该进程所占用的资源，并将其PCB从系统中删除。

这样，其他进程便可以继续使用这些资源，提高系统的效率和资源利用率。

实验二：进程调度算法进程调度算法是决定进程执行顺序的重要因素。

在本实验中，我们通过模拟不同的进程调度算法，比较它们在不同场景下的表现和效果。

我们选择了三种常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）和轮转调度（RR）。

通过设置不同的进程执行时间和优先级，我们观察到不同调度算法对系统吞吐量和响应时间的影响。

实验结果显示，FCFS算法适用于执行时间较短的进程，能够保证公平性，但在执行时间较长的进程出现时，会导致等待时间过长，影响系统的响应速度。

SJF 算法在执行时间较长的进程时表现出色，但对于执行时间较短的进程，可能会导致饥饿现象。

RR算法能够在一定程度上平衡各个进程的执行时间，但对于执行时间过长的进程，仍然会影响系统的响应速度。

实验三：进程同步与互斥在多进程环境中，进程之间的同步和互斥是必不可少的。

在本实验中，我们通过模拟进程间的竞争和互斥关系，观察进程同步与互斥的实现方式和效果。

我们选择了信号量机制和互斥锁机制作为实现进程同步和互斥的方法。

创建进程实验报告

一、实验目的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的数字。

操作系统实验(模拟进程管理)

操作系统实验————（1）模拟进程管理专业：信息管理与信息系统班级：信管082姓名：温静实验一进程管理1．目的和要求通过实验理解进程的概念，进程的组成（PCB结构），进程的并发执行和操作系统进行进程管理的相关原语（主要是进程的创建、执行、撤消）。

2．实验内容用C语言编程模拟进程管理，至少要有：创建新的进程；查看运行进程；换出某个进程；杀死运行进程以及进程之间通信等功能。

3．主体程序#include <conio.h>#include <stdio.h>#include <stdlib.h>struct PCB_type{ int pid;int priority;int cputime;int state;int shumu=0,pid_l;struct PCB_type neicun[20];struct PCB_type hc[10];int max=0;int number=0;void create();void run();void huanchu();void kill();/* 创建新进程*/void create(){if(shumu>=20){printf("\n内存已满，请先结束或换出进程\n");}else{shumu++;printf("\n请输入新进程的程序名\n");scanf("%d",&neicun[shumu-1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu-1].priority);printf("\n请输入新进程的运行时间\n");scanf("%d",&neicun[shumu-1].cputime);printf("\n创建进程时令其状态为就绪\n");neicun[shumu-1].state=2;}printf("\n创建进程成功!\n");}/* 查看当前运行进程*/void run(){int max=0;for(int i=0;i<shumu;i++){if((neicun[i].state==1)&&(neicun[i].priority>=neicun[max].priority)) max=i;}neicun[max].state=3;printf("当前运行进程程序名:\n%d",neicun[max].pid);printf("\n该进程的优先级:\n%d",neicun[max].priority);printf("\n该进程的运行时间:\n%d",neicun[max].cputime);printf("\n该进程的状态:\n%d",neicun[max].state);}/* 换出*/void huanchu(){int k;printf("请输入要换出程序的程序名:");scanf("%d",&k);for(int j=0;j<shumu;j++){if(neicun[j].state==1){hc[number].pid=neicun[j].pid;hc[number].state=neicun[j].state;hc[number].priority=neicun[j].priority;hc[number].cputime=neicun[j].cputime;number++;neicun[j].pid=0;neicun[j].state=0;neicun[j].priority=0;neicun[j].cputime=0;pid_1++;}else printf("进程%d无法换出的pid:%d\n",j.neicun[j].pid);if(number!=0)for(int i=0;i<number;i++){printf("当前运行进程程序名:\n%d",hc[i].pid);printf("\n该进程的优先级:\n%d",hc[i].priority);printf("\n该进程的运行时间:\n%d",hc[i].cputime);printf("\n该进程的状态:\n%d",hc[i].state);}}PCB_type temp=neicun[0];for(k=0;k<=shumu;k++){if(neicun[k].priority>temp.priority)tmpe=neicun[k];}neicun[k].state=1;}/* 杀死进程*/void kill(){neicun[max].pid=0;neicun[max].priority=0;neicun[max].cputime=0;neicun[max].state=0;if(max==(shumu-1))shumu--;else{for(int j=max+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}max=0;run();}/* int k=0;printf("请输入要杀死程序的进程名:");scanf("%d",&k);if(neicun[k].state=1)neicun[k].state=2;neicun[k].cputime=0;neicun[k].pid=0;neicun[k].priority=0;neicun[k].state=0;if(k==(shumu-1))shumu--;else{for(int j=k+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}printf("进程%d已被杀死!,k");}*/int main(){int n,a;n=1;while(n==1){system("cls");printf("\n**********************************************");printf("\n* 进程演示系统*");printf("\n**********************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.退出系统");printf("\n**********************************************");printf("\n请选择(1～5):");scanf("%d",&a);switch(a){ case 1:create( );printf("\npress anykey to go on~");getch();break;case 2 :run();printf("\npress anykey to go on~");getch();break;case 3 :huanchu();printf("\npress anykey to go on~");getch();break;case 4 :kill();printf("\npress anykey to go on~");getch();break;case 5 :exit(0);default:n=0;break;}}}5．感想与心得体会做了两周的实验，问了很多同学，可程序还是有很多问题。

实验一一进程创建实验

实验一一进程创建实验实验一（一）进程的创建实验实验目的1、掌握进程的概念，明确进程的含义2、认识并了解并发执行的实质实验内容1、编写一段程序，使用系统调用fork()创建两个子进程。

当此程序运行时，在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符：父进程显示"a"，子进程分别显示字符"b"和字符"c"。

试观察记录屏幕上的显示结果，并分析原因。

2、修改上述程序，每一个进程循环显示一句话。

子进程显示"daughter"及"son"，父进程显示"parent"，观察结果，分析原因。

实验准备（1）阅读LINUX的fork.c源码文件（见附录二），分析进程的创建过程。

（2）阅读LINUX的sched.c源码文件(见附录三)，加深对进程管理概念的认识。

实验指导一、进程UNIX中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。

一个进程实体由若干个区（段）组成，包括程序区、数据区、栈区、共享存储区等。

每个区又分为若干页，每个进程配置有唯一的进程控制块PCB，用于控制和管理进程。

PCB的数据结构如下：1、进程表项（ProcessTableEntry）。

包括一些最常用的核心数据：进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB的指针P_Link、指向U区进程正文、数据及栈在内存区域的指针。

2、U区（UArea）。

用于存放进程表项的一些扩充信息。

每一个进程都有一个私用的U区，其中含有：进程表项指针、真正用户标识符u-ruid(readuserID)、有效用户标识符u-euid(effectiveuserID)、用户文件描述符表、计时器、内部I/O参数、限制字段、差错字段、返回值、信号处理数组。

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

6、掌握进程另外的创建方法
7、熟悉进程的睡眠、同步、撤消等进程控制方法
二、实验内容
1）UNIX/LINUX及其使用环境
1、用vi编写一个简单的、显示"Hello,World!"的C程序，用gcc编译并观察编译后的结果
2、利用gdb调试该程序
3、运行生成的可执行文件。
2）进程创建：
1、编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。试观察记录屏幕上的显示结果，并分析原因。
操作系统实验报告
实验一进程的创建和控制
班级：12计算机12班
学号：127401219
姓名：刘艳仙
成绩：
2013年6月17日
一、实验目的
1、掌握进程的概念，明确进程的含义
2、复习C语言程序基本知识
3、练习并掌握UNIX提供的vi编辑器来编译C程序
4、学会利用gcc、gdb编译、调试C程序
5、认识并了解并发执行的实质
操作系统实验报告实验一进程的创建和控制12计算机12实验目的1掌握进程的概念明确进程的含义2复习c语言程序基本知识3练习并掌握unix提供的vi编辑器来编译c程序4学会利用gccgdb编译调试c程序5认识并了解并发执行的实质6掌握进程另外的创建方法7熟悉进程的睡眠同步撤消等进程控制方法实验内容1unixlinux及其使用环境1用vi编写一个简单的显示helloworld
#include <stdio.h>
#inlude<stdlib.h>
#include<unistd.h>

操作系统实验报告实验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、实现一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。