计算机操作系统实验一进程创建模拟实现

合集下载

操作系统实验实验报告

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

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

二、实验环境本次实验使用的操作系统为 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 等进行文件的创建、读取和写入操作。

(完整word版)操作系统实验报告.实验一 WINDOWS进程初识

操作系统教程实验指导书实验一WINDOWS进程初识1、实验目的（1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。

（2）掌握WINDOWS API的使用方法。

（3）编写测试程序，理解用户态运行和核心态运行。

2、实验内容和步骤（1）编写基本的Win32 Consol Application步骤1：登录进入Windows，启动VC++ 6.0。

步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。

创建一个新的控制台应用程序工程。

步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。

步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。

编译成可执行文件。

步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows “命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe运行结果 (如果运行不成功，则可能的原因是什么？) ：答：运行成功，结果：（2）计算进程在核心态运行和用户态运行的时间步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。

步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。

步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。

操作系统实验1

实验报告书学生姓名高雪学号班级计10A-2 2011 —2012 学年第一学期2021-8-19 第2页/共12页2021-8-19 第3页/共12页5.signal()signal()函数是允许调用进程控制软中断信号的处理。

6.pipe()函数pipe函数用于创建一个管道五、编译与执行过程截图1.进程的创建执行后出现acb和abc两种不同情况2.进程的控制〔1〕加锁情况：2021-8-19 第4页/共12页( 2 )没有加锁的情况3.进程的软中断通信2021-8-19 第5页/共12页4.进程的管道通信六、实验结果与分析1．进程的创建：实验一为进程创建，由以上截图可以看到产生了不同的结果，即acb和abc。

最初只有acb一种情况，反复执行之后，会出现abc。

原因很简单，就是因为进程的特性：并发性。

进程之间是并发执行的，并发只说一段时间内同时进行。

第一个输出一定是a,因为a在bc之外优先执行，而在执行bc的时候，2者会随机出现，多数情况会是acb,假设想更快的见到abc，可以讲c语句变长，如改为this is c child.这样进程需要的时间就稍长，后一个会先出现了。

但宏观来看，还是并行的。

2. 进程的控制实验二为进程控制，分为不加锁和加锁的情况，产生的结果不同，在不加锁的情况下，还有由于进程的执行具有并发性这个特征，因此会产生字符交叉的情况，即某一个进程在自己的时间片当中使用处理机，但是当时间片结束，还没有完成，但也必须由下一个进程接管处理机，因为它就进入了阻塞的状态。

多个进程反复出现，所以就出现了输出的字符交叉的情况。

但是，当我们对进程加锁后，就说明只能由该程序占用处理机，必须这些完这段程序才能执行下一段，因为不会出现交叉的情况，这个就是锁的作用。

2021-8-19 第6页/共12页2021-8-19 第7页/共12页2021-8-19 第8页/共12页2021-8-19 第9页/共12页2021-8-19 第10页/共12页2021-8-19 第11页/共12页2021-8-19 第12页/共12页。

计算机操作系统实验一进程创建模拟实现

答：1）申请空白PCB，为新进程申请获得唯一的数字标识符，并从PCB集合中索取一个空白PCB；2）为新进程分配资源，包括各种物理和逻辑资源，如内存、文件、I/O设备和CPU时间等；3）初始化进程控制块（PCB）；4）如果进程就绪队列能够接纳新进程，便将新进程插入就绪队列。
（2）该设计和实际的操作系统进程创建相比，缺少了哪些步骤?
***
实验时间:
***
一、实验目的
（1）理解进程创建相关理论;
（2）掌握进程创建方法;
（3）掌握进程相关数据结构。
二、实验内容
（1）输入给定代码;
（2）进行功能测试并得出正确结果;
（3）分析并掌握测试结果。
三、实验要求
实验要求：
（1）分析进程创建函数 createpc 程序模块;
（2）在实验报告中画出 createpc 函数程序流程图;
（3）撰写实验报告。
测试要求：
（1）至少创建 10 个进程;
（2）创建进程树中 4 层以上的树型结构。
实验环境：
（1）硬件环境：PC 机 1 台。
（2）软件环境：Microsoft Visual C++ 6.0。
四、设计与测试
（1）进程创建流程
1.申请空白 PCB:为新进程申请获得唯一的数字标识符，并从 PCB 集合中索取一个空白 PCB。如果无空白PCBБайду номын сангаас可以创建一个新的 PCB。在本实验中，每次动态创建 PCB。
2.为新进程分配资源:为新进程分配内存空间和栈空间。
3.初始化进程控制块:a.初始化标识信息;b.初始化处理机状态信息; c.初始化处理机控制信息。
4.将新进程插入就绪队列
（2）进程创建流程图

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

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

华科操作系统实验报告

华科操作系统实验报告一、实验目的操作系统是计算机系统的核心组成部分，对于理解计算机的工作原理和提高计算机应用能力具有重要意义。

本次华科操作系统实验的主要目的是通过实际操作和实践，深入理解操作系统的基本概念、原理和功能，掌握操作系统的核心技术和应用方法，提高我们的实践能力和问题解决能力。

二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 2004），开发工具包括 Visual Studio Code、GCC 编译器等。

实验硬件环境为个人计算机，配置为英特尔酷睿 i7 处理器、16GB 内存、512GB 固态硬盘。

三、实验内容1、进程管理进程创建与销毁进程调度算法模拟进程同步与互斥2、内存管理内存分配与回收算法实现虚拟内存管理3、文件系统文件操作与管理文件系统的实现与优化4、设备管理设备驱动程序编写设备分配与回收四、实验步骤及结果1、进程管理实验进程创建与销毁首先，使用 C 语言编写程序，通过系统调用创建新的进程。

在程序中，使用 fork(）函数创建子进程，并在子进程和父进程中分别输出不同的信息，以验证进程的创建和执行。

实验结果表明，子进程和父进程能够独立运行，并输出相应的信息。

进程调度算法模拟实现了先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）三种进程调度算法。

通过模拟多个进程的到达时间、服务时间和优先级等参数，计算不同调度算法下的平均周转时间和平均等待时间。

实验结果显示，SJF 算法在平均周转时间和平均等待时间方面表现较好，而 RR 算法能够提供较好的响应时间和公平性。

进程同步与互斥使用信号量和互斥锁实现了进程的同步与互斥。

编写了生产者消费者问题的程序，通过信号量控制生产者和消费者对缓冲区的访问，避免了数据竞争和不一致的情况。

实验结果表明，信号量和互斥锁能够有效地实现进程间的同步与互斥，保证程序的正确性。

2、内存管理实验内存分配与回收算法实现实现了首次适应（First Fit）、最佳适应（Best Fit）和最坏适应（Worst Fit）三种内存分配算法。

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

进程的创建
一.实验目的
1、掌握进程的概念，明确进程的含义。

2、认识并了解并发执行的实质。

二.实验内容
编写一段程序，使用系统调用fork( )创建一个子进程。

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

让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程显示字符'b'。

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

三.实验过程及结果
1.打开centos，在文档中输入创建进程的代码。

图1 代码界面
2.在桌面上右击，在下拉列表中选择Open in Terminal，打开控制台，然后输入编译和运行的命令，当输入编译命令的时候，桌面会生成一个a.out的文件。

图2 编译界面
3.当输入运行命令，就会显示出结果了
图3 最终结果
四.实验小结
1.代码在执行的时候，就创建了一个进程，此时的进程是父进程。

2.当代码执行到fork()函数时，就创建了一个子进程，因为子进程是继承父进程的，所以他们的内容基本上是一样的。

3.可以看到，在最后输入运行命令时，同时跳出两个结果，证明了进程是并发执行的。

4.对于进程的定义，从不同的角度有不同的定义，较典型的有：进程是程序的一次执行，进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位等。

5.并发执行就是指两个或者多个事件在同一时间间隔内发生。

操作系统进程调度模拟程序实验报告

操作系统进程调度模拟程序实验报告实验目的：了解操作系统进程调度的基本原理和方法，通过编写模拟程序来验证调度算法的正确性。

实验内容：1. 实现进程调度模拟程序，包括进程的创建、调度、挂起、恢复和销毁等基本操作。

2. 实现三种常用的调度算法：先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。

3. 对比不同调度算法的性能，包括平均等待时间、平均周转时间和平均响应时间等指标。

实验步骤：1. 首先定义进程类Process，包括进程的ID、到达时间、执行时间和优先级等属性。

2. 实现创建进程的函数create_process，通过用户输入的方式创建多个进程，并保存到一个进程队列中。

3. 根据选择的调度算法，实现调度函数schedule，按照对应的算法对进程进行调度，并记录每个进程的执行时间和等待时间等信息。

4. 对于FCFS算法，按照进程的到达时间进行排序，然后按顺序执行。

5. 对于SJF算法，按照进程的执行时间进行排序，然后按顺序执行。

6. 对于RR算法，设定一个时间片大小，每个进程执行一个时间片后，将其放回队列末尾，然后继续执行下一个进程，直到所有进程都执行完毕。

7. 在各个调度算法中计算平均等待时间、平均周转时间和平均响应时间等指标，并输出结果。

实验结果：通过对不同进程和不同调度算法的模拟，可以得到如下结果：1. FCFS调度算法的平均等待时间较长，不适用于执行时间较长的任务。

2. SJF调度算法的平均等待时间和平均周转时间较短，适用于执行时间较短的任务。

3. RR调度算法能够平均分配CPU时间，适用于执行时间较长的任务。

实验总结：通过本次实验，我们进一步加深了对操作系统进程调度的理解和认识。

通过编写模拟程序，我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。

在实际应用中，根据任务的特点和需求选择合适的调度算法，能够提高系统的性能和效率。

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

操作系统实验————（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、掌握进程的创建、终止和调度方法。

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资源给各个进程。

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

操作系统实验报告范文模板这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和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实现进程之间的同步：建立司机和售票员进程；并实现他们间的同步运行。

操作系统实验一模拟进程状态转换

实验一模拟进程状态转换及其PCB的变化一、实验目的：自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。

二、实验内容及要求：（1）、设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。

（2）、独立编写、调试程序。

进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。

（3）、合理设计与进程PCB相对应的数据结构。

PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。

（4）、设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。

（5）、代码书写要规范，要适当地加入注释。

（6）、鼓励在实验中加入新的观点或想法，并加以实现。

（7）、认真进行预习，完成预习报告。

（8）、实验完成后，要认真总结，完成实验报告。

三、实现:数据结构struct PCB{char name;int priority;int needtime;bool operator < (const PCB &b) const{ return priority>b.priority;}};五状态进程模型最高优先数优先调度算法流程图四、运行结果：图1 创建2个进程，因为这时cpu空闲所以内核调度，b优先级高先执行图2 超时，因为这时cpu空闲所以内核调度，b优先级还是比a高所以先执行图3 2个进程均被阻塞，其中一旦进程被阻塞就会引发调度图4 唤醒1个进程，从阻塞队列取队首放到就绪队列队尾，由于这时cpu空闲所以内核调度五、源代码：#include<cstdio>#include<algorithm>using namespace std;int Ready_len=0;int Blocked_len=0;int CPU_state=0;struct PCB{char name;int priority;int needtime;bool operator < (const PCB &b) const{ return priority>b.priority;}};PCB Ready[100];PCB Blocked[100];PCB Cpu;bool dispatch();bool creat(int NUM){//创建一个新的进程while(NUM--){printf("输入进程名(一个字符)、所需时间(一个整数)、优先级(一个整数): \n");scanf("%s%d%d",&(Ready[Ready_len].name),&(Ready[Ready_l en].needtime),&(Ready[Ready_len].priority));getchar();Ready_len++;}if(CPU_state==0)//如果CPU空闲，则调度dispatch();}bool dispatch(){if(CPU_state==0){if(Ready_len!=0){sort(Ready,Ready+Ready_len);=Ready[0].name;Cpu.needtime=Ready[0].needtime; Cpu.priority=Ready[0].priority;if(Ready_len!=1)//就绪队列剔除队首元素for(int indx=1;indx<Ready_len;indx++){Ready[indx-1].name=Ready[indx].name;Ready[indx-1].needti me=Ready[indx].needtime;Ready[indx-1].priority=Ready[indx] .priority;}Ready_len--;CPU_state=1;printf("***%c进程送往CPU执行\n",);Cpu.needtime--;Cpu.priority--;}else{printf("***就绪队列为空，无法调度\n");return false;}}else{printf("***CPU忙，无法调度\n");}}bool time_out(){if(CPU_state==1){if(Cpu.needtime==0)printf("***%c时间片用完，并且执行完毕，被释放\n",);else{Ready[Ready_len].name=;Ready[Ready_len].needti me=Cpu.needtime;Ready[Ready_len].priority=Cpu.priority;Ready_len++;printf("***%c时间片用完\n",);}CPU_state=0;=0;Cpu.needtime=0;Cpu.priority=0;if(Ready_len!=0)//时间片用完，如果就绪队列不为空，则调度dispatch();}else{printf("***没有进程在CPU中，无法超时\n");}}bool event_wait(){if(CPU_state==1){Blocked[Blocked_len].name=;Blocked[Blocked_le n].needtime=Cpu.needtime;Blocked[Blocked_len].priority=Cp u.priority;Blocked_len++;printf("***%c被阻塞\n",);CPU_state=0;if(Ready_len!=0)//进程被阻塞，如果就绪队列不为空，则调度dispatch();}elseprintf("***没有进程在CPU中，无法阻塞\n");}bool event_occur(){if(Blocked_len!=0){//sort(Blocked,Blocked+Blocked_len);Ready[Ready_len].name=Blocked[0].name;Ready[Ready_len].n eedtime=Blocked[0].needtime;Ready[Ready_len].priority=Bloc ked[0].priority;Ready_len++;if(Blocked_len!=1)//阻塞队列剔除队首元素for(int indx=1;indx<Blocked_len;indx++){Blocked[indx-1].name=Blocked[indx].name;Blocked[indx-1].ne edtime=Blocked[indx].needtime;Blocked[indx-1].priority=Bloc ked[indx].priority;}Blocked_len--;//printf("%d %d",Blocked_len,Ready_len);printf("***%c被唤醒\n",Ready[Ready_len-1].name);if(CPU_state==0)//如果CPU空闲，则调度dispatch();//printf("%d %d",Blocked_len,Ready_len);}elseprintf("***阻塞队列为空，无法唤醒\n");}int main(){int Cputime=1;while(1){printf("\n1:New\t\t\t2:Dispatch\n");printf("3:Timeout\t\t4:Event wait\n"); printf("5:Event occur\t\t0:exit\n");printf("输入1--5实现相应的功能：\n"); int select;scanf("%d",&select);getchar();switch(select){case 1:int num;printf("输入要创建的进程数：\n");scanf("%d",&num);getchar();creat(num);break;case 2:dispatch();break;case 3:time_out();break;case 4:event_wait();break;case 5:event_occur();break;case 0:exit(0);break;}printf("****************************Cputime:%3d************ ****************\n",Cputime);printf("状态\t\t进程名\t\t需要时间\t\t优先级\n");if(CPU_state){//显示CPU中的进程printf("Running:\t%c\t\t",);printf("%d\t\t\t",Cpu.needtime);printf("%d\n",Cpu.priority);}if(Ready_len){//显示Ready队列中的进程for(int a=0;a<Ready_len;a++){printf("Ready%d:\t\t",a);printf("%c\t\t",Ready[a].name);printf("%d\t\t\t",Ready[a].needtime);printf("%d\n",Ready[a].priority);}}if(Blocked_len){//显示Blocked队列中的程序for(int b=0;b<Blocked_len;b++){printf("Blocked%d:\t",b);printf("%c\t\t",Blocked[b].name);printf("%d\t\t\t",Blocked[b].needtime);printf("%d\n",Blocked[b].priority);}}printf("****************************************************** *************\n");Cputime++;}}。

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

《操作系统原理》进程的创建与管理实验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中。

实验一进程创建模拟

2) 进程创建流程 (1) 申请空白 PCB 为新进程申请获得唯一的数字标识符，并从 PCB 集合中索取一个空白 PCB。如果无空白PCB，可以创建一个新的 PCB。在本实验中，每次动态创建 PCB。 (2) 为新进程分配资源为新进程分配内存空间和栈空间。 (3) 初始化进程控制块 a) 初始化标识信息； b) 初始化处理机状态信息； c) 初始化处理机控制信息。 (4) 将新进程揑入就绪队列
(3) 进程调度信息 a) 进程状态； b) 进程优先级（用亍描述优先使用 cpu 级别的一个整数，高优先级的进程先得到cpu，通常情况下，优先值越小优先级越高）； c) 其它信息（等待时间、总执行时间等）； d) 事件（等待原因）。 (4) 进程控制信息 a) 程序和数据的地址（程序在内存和外存中的首址）； b) 进程同步和通信机制； c) 资源列表（进程除 CPU 以外的所有资源）； d) 链接指针（进程队列中指向下一个进程的 PCB 首址）。
实验一
进程创建模拟
一、实验目的 1）理解进程创建相关理论； 2）掌插进程创建方法； 3）掌插进程相关数据结构。
二、实验内容本实验针对操作系统中进程创建相关理论进行实验。要求实验者输入实验指导书提供的代码并进行测试。代码简化了进程创建的多个步骤和内容。进程的树形结构采用广义二叉树的方式进行存储。
三、实验原理 1）进程控制块为了描述和控制进程的运行，系统为每个进程定义了一个进程控制块（PCB），它是进程实体的一部分，是操作系统管理进程最重要的数据结构。其主要包含四类信息： (1) 进程标识符它唯一地标识一个进程。通常包括进程号 pid，父进程号 ppid 和用户号 uid。 (2) 处理机状态处理器的状态通常由处理机的各种寄存器中的内容组成。PCB 存放中断（阻塞，挂起）时的各寄存器值，当该进程重新执行时，可以从断点处恢复。主要包括： a) 通用寄存器； b) 指令计数器； c) 程序状态字 PSW； d) 用户栈指针。

实验一一进程创建实验

实验一一进程创建实验实验一（一）进程的创建实验实验目的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、数据结构进程控制块 pcb 和进程队列结构1)进程控制块pcb定义中定义了pcb结构。

该结构中各符号的意义说明如下:struct pcb{int id /*进程id号*/name[10]; /*进程符号名*/regx reg; /*进程现场保护区*/priority; /*进程优先级*/status; /*进程状态指针*/next;/*进程当前队列链接字*/all_q_next;/*总链队列链接字*/ }pcba[num4];2）进程现场保护区regx定义typedef strust regist{ int flag;1nt ax;int bx;int cx;int dx;int si;int di;int bp;int ds;1nt es;lnt sp;int SS;int ip;int cs;}regx;2、算法1）进程的创建创建一个指名进程，调用格式为：pcbcreat(name);该调用的入口是一个字符指针，指向创建进程符号名字符串，出口是创建进程pcb的地址，它由一个全程变量pcb_addr指向创建进程pcb的首址。

创建一个进程的主要工作是找一个空的pcb 结构(即id=-1的pcb结构),然后根据系统进程和用户进程的不同填写pcb的信息。

用户进程的id 为pcb结构数组中的序号,状态为"ready“。

其优先级在prio的基础上变化。

而系统进程的id应设置为一个特殊值(例如100),其状态为"system",优先级定为0。

模拟进程创建实验报告(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. 理解进程的概念和进程创建的过程。

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、进一步认识并发执行的实质。

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

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

（2）语言级—以普通程序员身份认识高级语言Java的进程创建与撤销工具。

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

三、实验步骤1、windows的进程管理（1）按ctrl+alt+delete键，弹出windows任务管理器窗口（2）选择相应操作序号，可以创建一个新的进程（3）在创建完一个新的进程后，可以显示出所有已创建进程的详细信息（4）选择相应操作序号，可以通过输入pcbId或pcbGrade来撤销一个进程2、进程创建与撤销工具（1）进程的创建Process p=Runtime.getRuntime().exec("notepad");（2）进程的撤销p.destroy();3、进程创建与撤销的模拟实现（1）总体设计：①数据结构定义：结构体PCB：进程编号，进程名称，进程优先级和进程创建时间，队列按进程创建时间排序。

PCB空间就绪队列指针空队列指针②函数进程创建：从PCB空间申请一个空PCB，填入进程参数，插入就绪队列；进程终止：将指定的就绪进程移出就绪队列，插入空队列；就绪队列输出：输出就绪队列中的进程信息，以便观察创建或撤消活动的结果；主函数：调用创建函数、调用终止函数、输出就绪队列；③主界面设计：进程创建、进程撤销、退出程序图1 操作主界面④功能测试：从显示出的就绪队列状态，查看操作的正确与否。

（2）详细设计：①数据结构定义：结构体PCB：表1 PCB结构体表PCB空间：是一个能存放十个PCB对象的数组就绪队列指针：定义一整型变量初始值为零空队列指针：定义一整型变量初始值为零，当有进程创建时，加入。

计算机操作系统实验一进程创建模拟实现

操作系统实验实验报告

(完整word版)操作系统实验报告.实验一 WINDOWS进程初识

操作系统实验1

计算机操作系统实验一进程创建模拟实现

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

华科操作系统实验报告

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

操作系统进程调度模拟程序实验报告

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

计算机操作系统实训教程之进程的创建实验报告

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

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

操作系统实验一模拟进程状态转换

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

实验一 进程创建模拟

实验一一进程创建实验

操作系统实验一进程创建

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

进程创建实验报告

实验一进程的创建与撤销

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

实验一进程创建模拟