进程创建实验报告

合集下载

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

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。

三、实验内容及步骤（一）进程创建实验1、首先，创建一个新的 C+＋项目。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

进程创建实验报告

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

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

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

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

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

二、实验环境本实验使用的是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. 观察输出结果运行程序后，我们可以观察到输出结果。

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

实验一进程的创建和撤销一、实验目的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参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。

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

操作系统实验报告试验一：进程创建与撤销计科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也唯一地标示其所在的线程。

进程管理实验报告_共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族调用可以执行给定程序。

实验一进程创建 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之后父进程才可能被调度运行，当子进程调用这两个函数中的任意一个时，父进程会恢复运行。

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

实验一_进程创建与撤销报告实验目的：1.了解进程控制块（PCB）及其作用。

2.掌握进程的创建和撤销操作。

实验原理：进程是操作系统中最基本的一种资源。

在操作系统中，每个进程由进程控制块（PCB）来描述，PCB是操作系统内核中的一种数据结构，它用于存放操作系统所需要的进程控制信息。

一个进程创建时，操作系统会为该进程分配一个独立的PCB，然后将进程的各种资源和状态信息记录到PCB中。

进程撤销时，操作系统会将进程所占用的资源和状态信息清除，并且释放该进程对应的PCB。

进程的创建可以通过系统调用fork、exec等来实现。

fork系统调用会创建一个新的进程，该新进程与原有进程具有相同的程序代码。

exec系统调用会从磁盘上装载一个新的程序覆盖当前进程，因此它与fork系统调用的操作不同。

进程的撤销可以通过系统调用exit来实现。

exit系统调用会立刻终止当前进程的运行并撤销其所有资源。

此外，还可以通过kill系统调用向指定的进程发送SIGKILL信号来马上终止该进程。

实验内容：本次实验的主要任务是编写一段程序，通过系统调用来创建进程并执行相应的操作。

1.创建子进程：使用fork系统调用创建一个子进程，该子进程与父进程具有相同的代码和数据。

子进程输出一句话，例如：“This is child process，PID=子进程ID”。

3.父进程等待：5.进程撤销：父进程使用exit系统调用退出，首先输出一句话：“Parent process is exiting...”，然后将进程占用的资源归还给系统。

实验步骤：1.打开终端并进入Linux虚拟机系统。

2.使用文本编辑器编写C语言代码，保存为myproc.c文件，然后使用gcc编译该文件。

3.在终端中输入./myproc命令，运行该程序，观察输出结果。

4.清理该程序占用的资源，方法是在终端中输入killall myproc命令。

实验结果：./myprocChild process has finished。

进程的创建实验报告

操作系统实验报告哈尔滨工程大学计算机科学与技术学院一、实验概述1. 实验名称进程的创建2. 实验目的(1)练习使用EOS API函数CreateProcess创建一个进程，掌握创建进程的方法，理解进程和程序的区别。

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

3. 实验类型验证性实验4. 实验内容二、实验环境EOS操作系统三、实验过程1. 设计思路和流程图2.算法实现3.需要解决的问题及解答(1)在源代码文件NewTwoProc.c提供的源代码基础上进行修改，要求使用hello.exe同时创建10个进程。

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

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

答：后文中，有此题解决方案。

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

(3)在PsCreateProcess函数中调用了PspCreateProcessEnvironment函数后又先后调用了PspLoadProcessImage和PspCreateThread函数，学习这些函数的主要功能。

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

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

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

PspCreateThread创建了进程的主线程。

这三个函数被调用的顺序是不能够改变的就向上面描述的加载可执行映像之前必须已经为进程创建了地址空间这样才能够确定可执行映像可以被加载到内存的什么位置在创建主线程之前必须已经加载了可执行映像这样主线程才能够知道自己要从哪里开始执行，执行哪些指令。

操作系统实验报告(进程的创建).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()。

进程创建实验报告

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

模拟进程创建实验报告(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. 编写主函数，模拟进程创建、运行和销毁过程。

实验一进程创建模拟报告

实验一进程创建模拟实验学时：2实验类型：验证实验要求：必修一、实验目的1）理解进程创建相关理论；2）掌握进程创建方法；3）掌握进程相关数据结构。

二、实验容本实验针对操作系统中进程创建相关理论进行实验。

要验者输入实验指导书提供的代码并进行测试。

代码简化了进程创建的多个步骤和容。

进程的树形结构采用广义二叉树的方式进行存储。

三、实验原理1）进程控制块为了描述和控制进程的运行，系统为每个进程定义了一个进程控制块（PCB），它是进程实体的一部分，是操作系统管理进程最重要的数据结构。

其主要包含四类信息：(1) 进程标识符它唯一地标识一个进程。

通常包括进程号 pid，父进程号 ppid 和用户号 uid。

(2) 处理机状态处理器的状态通常由处理机的各种寄存器中的容组成。

PCB 存放中断（阻塞，挂起）时的各寄存器值，当该进程重新执行时，可以从断点处恢复。

主要包括：a) 通用寄存器；b) 指令计数器；c) 程序状态字 PSW；d) 用户栈指针。

(3) 进程调度信息a) 进程状态；b) 进程优先级（用于描述优先使用 cpu 级别的一个整数，高优先级的进程先得到cpu，通常情况下，优先值越小优先级越高）；c) 其它信息（等待时间、总执行时间等）；d) 事件（等待原因）。

(4) 进程控制信息a) 程序和数据的地址（程序在存和外存中的首址）；b) 进程同步和通信机制；c) 资源列表（进程除 CPU 以外的所有资源）；d) 指针（进程队列中指向下一个进程的 PCB 首址）。

2) 进程创建流程(1) 申请空白 PCB为新进程申请获得唯一的数字标识符，并从 PCB 集合中索取一个空白 PCB。

如果无空白PCB，可以创建一个新的 PCB。

在本实验中，每次动态创建 PCB。

(2) 为新进程分配资源为新进程分配存空间和栈空间。

(3) 初始化进程控制块a) 初始化标识信息；b) 初始化处理机状态信息；c) 初始化处理机控制信息。

(4) 将新进程插入就绪队列3) 进程树P1P2 P3 P4 P5P6 P7 P8 P9 P10 P11P12图 1-1 进程树进程树用于描述进程家族关系，如图 1-1 中可以看出，进程 P1 创建了进程 P2、P3、P4、P5，而 P2 又创建了 P6、P7、P8 …… 。

实验一一进程创建实验

实验一一进程创建实验实验一（一）进程的创建实验实验目的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参数、限制字段、差错字段、返回值、信号处理数组。

进程创建撤销实验报告

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

2. 掌握进程创建和撤销的基本原理和方法。

3. 通过实验加深对进程管理机制的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 编译器：GCC三、实验原理在操作系统中，进程是系统进行资源分配和调度的基本单位。

进程创建是指从无到有地创建一个新的进程，而进程撤销则是指结束一个进程的生命周期。

进程创建和撤销是操作系统进程管理中的重要操作。

四、实验内容1. 进程创建实验2. 进程撤销实验五、实验步骤1. 进程创建实验（1）创建一个新进程```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid = fork(); // 创建子进程if (pid == -1) {perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process: PID = %d\n", getpid());// 执行子进程的任务} else {// 父进程printf("Parent process: PID = %d\n", getpid());// 等待子进程结束wait(NULL);}return 0;}```（2）编译并运行程序```bashgcc -o process_create process_create.c./process_create```（3）观察输出结果在控制台会看到两个进程的PID，其中一个为父进程，另一个为子进程。

2. 进程撤销实验（1）创建一个新进程```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid = fork(); // 创建子进程if (pid == -1) {perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process: PID = %d\n", getpid()); // 执行子进程的任务sleep(10); // 子进程睡眠10秒} else {// 父进程printf("Parent process: PID = %d\n", getpid()); // 等待子进程结束wait(NULL);}return 0;}```（2）编译并运行程序```bashgcc -o process_destroy process_destroy.c./process_destroy```（3）观察输出结果在控制台会看到两个进程的PID，父进程会等待子进程结束。

操作系统第2次实验报告：创建进程

操作系统第2次实验报告：创建进程姓名：王丕杰学号：201821121052班级：计算1812⼀、实验⽬的熟练Linux创建进程fork操作。

⼆、实验内容在服务器上⽤VIM编写⼀个程序：⼀个进程创建两个⼦进程。

查看进程树查看进程相关信息三、实验报告1、编写程序在服务器上⽤VIM编辑器编写⼀个程序：⼀个进程创建（fork）两个⼦进程。

程序命名为 forktest.c给出源代码：1 #include<stdio.h>2 #include<sys/types.h>3 #include<unistd.h>4 int main ()5 {6 pid_t fpid;7 for(int i=0;i<2;i++){8 fpid=fork();9 if(pid==0||pid==-1){10 break;11 }12 }13 if(fpid==0){14 printf("Child proces: %d\n",getpid());15 }16 else if(fpid==-1){17 printf("error\n");18 }19 else{20 printf("Parent process: %d\n",getpid());21 }22 sleep(200);23 return 0;24 }2、打印进程树编译程序并运⾏：打印进程树：3、解读进程相关信息(1) ps -ef相应字段解析：UID：⽤户ID（此处为wangpijie）PID：进程ID（此处为4173、4174、4175等）PPID：该进程的⽗进程ID（例如⼦进程4174、4175对应其⽗进程4173）C：该进程占⽤CPU的百分⽐（此处为0）STIME：进程开始时间（此处为11:33）TTY：登录进程终端机位置（此处为pts/1）TIME：进程运⾏时间（此处为00:00:00）CMD：运⾏该进程所下达的指令（此处为 ./forktest）(2) ps -aux相应字段解析：USER：⽤户名（此处为wangpijie）PID：进程ID（此处为4173、4174、4175等）%CPU：CPU占⽐（0.0）%MEN：内存占⽐（0.0）VSZ：占⽤虚拟记忆体的⼤⼩RSS：占⽤记忆体的⼤⼩TTY：登录进程终端机位置（此处为pts/1）STAT：进程状态（此处S表⽰中断，显⽰S+是因为包括⼦进程）START：进程开始时间（此处为11:33）TIME：进程运⾏时间（此处为0:00）COMMAND：运⾏该进程所下达的指令（此处为 ./forktest）4、通过该实验产⽣新的疑问及解答疑问：实验过程中在运⾏程序后，执⾏pstree -p pid仍⽆法打印出进程树解答：（1）需要打开两个终端窗⼝，⼀个运⾏程序，⼀个执⾏ pstree -p pid 打印进程树（2）程序中sleep()挂起进程的时间太短，导致进程树⽆法打印，增加挂起进程的时间即可。

进程创建实验报告范文-图文

进程创建实验报告范文-图文（计算机学院）课内实验报告实验名称：进程管理-进程调度专业名称计算机科学与技术班级：学生姓名：学号（8位）指导教师：实验日期：一.实验目的及实验环境1.实验目的通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在POSI某规范中fork和kill系统调用的功能和使用。

2.实验环境（1）硬件显示器：NVIDIAGeForceGT某850M硬盘空间：1.0TB（2）软件虚拟机名称及版本：VM12.0操作系统名称及版本：Cento6.7编译器：GCC二.实验内容1、实验前准备工作根据下发的Linu某进程管理实验PPT内容，将实验代码补充完整。

并考虑：先猜想一下这个程序的运行结果。

假如运行“./proce20”，输出会是什么样？然后按照注释里的要求把代码补充完整，运行程序。

可以多运行一会儿，并在此期间启动、关闭一些其它进程，看proce的输出结果有什么特点，记录下这个结果。

开另一个终端窗口，运行“pau某|grepproce”命令，看看proce究竟启动了多少个进程。

回到程序执行窗口，按“数字键+回车”尝试杀掉一两个进程，再到另一个窗口看进程状况。

按q退出程序再看进程情况。

3、回答问题编写、编译、链接、执行实验内容设计中的代码，并回答如下问题：1）你最初认为运行结果会怎么样？答：子进程按序号输出。

2）实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。

答：子进程基本按序号输出，但有几个顺序错误，可能是某些子进程执行太快，抢占资源，导致顺序错误。

3）proc_number这个全局变量在各个子进程里的值相同吗？为什么？答：相同，因为全局变量是共享资源，所以值相同。

4）kill命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？杀死，不会出现在主进程中，第二次是杀死本组全部子进程，杀死后程序只剩主进程。

5）使用kill命令可以在进程的外部杀死进程。