惠州学院操作系统进程的创建与并发执行实验(精编文档).doc

《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一，本次实验的主要目的是深入理解操作系统的基本原理和功能，通过实际操作和观察，熟悉操作系统的核心概念，包括进程管理、内存管理、文件系统和设备管理等，提高对操作系统的实际应用能力和问题解决能力。

二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019编程语言：C+＋三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。

在这个实验中，我们使用C+＋编写程序来创建和管理进程。

通过观察进程的创建、执行和结束过程，理解进程的状态转换和资源分配。

首先，我们编写了一个简单的程序，创建了多个子进程，并通过进程标识符（PID）来跟踪它们的运行状态。

然后，使用等待函数来等待子进程的结束，并获取其返回值。

在实验过程中，我们发现进程的创建和销毁需要消耗一定的系统资源，而且进程之间的同步和通信需要谨慎处理，以避免出现死锁和竞争条件等问题。

2、内存管理实验内存管理是操作系统的核心功能之一，它直接影响系统的性能和稳定性。

在这个实验中，我们研究了动态内存分配和释放的机制。

使用 C+＋中的 new 和 delete 操作符来分配和释放内存。

通过观察内存使用情况和内存泄漏检测工具，了解了内存分配的效率和可能出现的内存泄漏问题。

同时，我们还探讨了内存分页和分段的概念，以及虚拟内存的工作原理。

通过模拟内存访问过程，理解了页表的作用和地址转换的过程。

3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。

在这个实验中，我们对文件的创建、读写和删除进行了操作。

使用 C+＋的文件流操作来实现对文件的读写。

通过创建不同类型的文件（文本文件和二进制文件），并对其进行读写操作，熟悉了文件的打开模式和读写方式。

此外，还研究了文件的权限设置和目录的管理，了解了如何保护文件的安全性和组织文件的结构。

4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。

广州商学院操作系统实验报告（第 2 次）实验名称：进程的创建与并发执行之一实验时间：2021/3/31一．实验目的（1）理解进程与程序的联系与区别以及并发程序的基本特性。

（2）学会在在程序中使用fork() 函数创建克隆式子进程的基本编程方法。

二．实验内容命令进程的创建与并发执行三．实验主要步骤实验2.1 命令进程的创建与并发执行②启动Linux，进入黑屏界面；②在tty1上用root账号登录，在tty2和tty3上则分别以普通用户账号登录；③在tty1上输入命令“ps --help”，即在tty1上创建命令进程ps，以查看ps命令的help信息；④在tty2上输入命令“man man”，即在tty2上创建命令进程man，以查看man命令的help信息，不要终止该man命令；⑤在tty3上执行命令“man pstree”，即在tty3上创建命令进程man，查看pstree命令的help信息，同样也不要终止该man命令；⑥在tty1上执行ps命令，查看本控制台上所有进程的基本信息；⑦在tty1上执行pstree命令，查看进程的分层结构。

⑧再在tty1上执行ps命令，查看本系统的所有进程的详细信息，并从中找到并记下tty2上的man命令进程的PID；你能看到ps命令输出的全部信息吗？如果不能，可以利用Linux的“重定向”或“管道”功能，例如，可输入如下管道命令行：ps –aux | more该命令行的语义是：将ps命令的输出结果作为输入传递给more命令（分页显示），并执行more命令。

)⑨撤消tty2上的man命令进程；⑩再执行ps命令，查看被撤消的进程是否还存在；⑾切换到tty2，观察man命令是否还在执行或已终止；再切换到tty3，观察man命令是否还在执行或已终止；tty2（已经终止）tty3（未终止）⑿注销（不要关机）。

tty3tty2tty1实验2.2 使用fork创建进程本实验使用系统调用fork()创建多个子进程，实现多进程并发执行。

中南大学《操作系统》实验报告姓名：孙福星专业班级：软件 1006班学号：3902100610完成日期：2011.11.22进程调度与内存管理一、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就续进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

实验模拟实现处理机调度，以加深了解处理机调度的工作，并体会优先级和时间片轮转调度算法的具体实施方法。

帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收。

二、实验要求1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1/要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度。

4、可随时增加进程；5、规定道数，设置后备队列和挂起状态。

若内存中进程少于规定道数，可自动从后备队列调度一作业进入。

被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。

6、每次调度后，显示各进程状态。

7、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表；表目内容：起址、长度、状态（未分/空表目）8、结合以上实验，PCB增加为：{PID，要求运行时间，优先权，状态，所需主存大小，主存起始位置，PCB指针}9、采用最先适应算法分配主存空间；10、进程完成后，回收主存，并与相邻空闲分区合并。

11、采用图形界面；三、实验内容选择一个调度算法，实现处理机调度。

1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。

3、主存储器空间的分配和回收。

在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收。

四、实验原理该模拟系统采用java语言实现，要实现的功能有新建进程、进程调度、挂起进程、解挂进程、删除进程，道数和时间片大小可以由用户自己调整，有两种调度策略：按优先权调度和按时间片轮转调度。

每个进程可能有5种状态：新建(new)、就绪(ready)、运行(running)、阻塞(waiting)、挂起(suspend)。

实验二进程的创建与控制姓名：梁斌学号：20121060186专业：计算机科学与技术（国防）一、实验目的1.加深对进程概念的理解，认识并发执行的本质。

2.分析进程竞争资源的现象，学习解决互斥的方法。

二、实验主要内容及设计1.使用fork( )创建两个子进程。

2.使用lockf( )给进程加锁。

三、实验内容及完成结果编写一段程序，使用系统调用fork( )创建两个子进程。

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

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

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

〈程序〉# include<stdio.h>main(){int p1,p2;while((p1＝fork())= = -1)；/*创建子进程p1*/ if(p1= =0) /*子进程创建成功*/putchar(…b‟);else{while((p2= fork())= = -1);/*创建另一个子进程*/if(p2= =0)/*子进程创建成功*/putchar(…c‟)；else putchar(…a‟)；/*父进程执行*/}}<运行结果>四、结果及分析1.给出fork ( )的流程图fork( )流程图2.对进程创建中的程序进行分析为了进一步了解和进程如何创建，以及子进程和父进程的调用顺序和执行的代码，对上述程序做了如下修改# include<stdio.h>main(){int p1,p2;while((p1＝fork())= = -1)；printf(“p1=%d\n”,p1); /*p1为任意整数，调用父进程；p1为0，调用子进程*/if(p1= =0)printf(“b\n”);else{while((p2= fork())= = -1);printf(“p2=%d\n”,p2);/* p2为任意整数，调用父进程；p2为0，调用子进程*/if(p2= =0)printf(“c\n”);else printf(“a\n”);；}}执行结果分析：1.父进程和子进程的代码段都是上面的所有代码，不过子进程的代码只从创建此子进程那里开始执行2.程序在创建子进程的时候返回两个值：一个任意正整数(子进程的ID)，返回给父进程；一个0，返回给子进程3.执行结果是bca，也就是系统在创建玩b,c两个子进程后，先调用执行b进程，输出‟b‟，接着调用执行c进程，输出‟c‟，最后执行父进程，输出‟a‟4.之所以有其他不同的字母输出顺序，是因为三个进程抢占cpu不同，从而导致三个进程被cpu调用执行的顺序不同，从而有不同的输出。

最新文件---------------- 仅供参考--------------------已改成-----------word文本 --------------------- 方便更改赠人玫瑰，手留余香。

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

2.调试跟踪CreateProcess函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位3. 实验类型验证型实验4. 实验内容（1）准备实验（2）练习使用控制台命令创建EOS应用程序的进程（3）练习通过编程的方式让应用程序创建另一应用程序的进程。

（4）调试Create Process函数（5）调试Ps Create Process函数（6）练习通过编程的方式创建应用程序的多个进程二、实验环境EOS实验系统，WINDOWS XP 操作系统三、实验过程1. 设计思路和流程图2.算法实现（1）创建十个进程代码#include "EOSApp.h"int main(int argc, char* argv[]){STARTUPINFO StartupInfo;PROCESS_INFORMATION A[10];ULONG ulExitCode; // 子进程退出码INT nResult = 0; // main 函数返回值。

0 表示成功，非 0 表示失败。

#ifdef _DEBUG__asm("int $3\n nop");#endifprintf("Create ten processes and wait for the processes exit...\n\n");StartupInfo.StdInput = GetStdHandle(STD_INPUT_HANDLE);StartupInfo.StdOutput = GetStdHandle(STD_OUTPUT_HANDLE);StartupInfo.StdError = GetStdHandle(STD_ERROR_HANDLE);int x[10],i=0;x[10]=0;for(i=0;i<10;i++){if(CreateProcess("A:\\Hello.exe", NULL, 0, &StartupInfo, &A[i])==0)x[i]=1;}for(i=0;i<10;i++){if(x[i]==0)WaitForSingleObject(A[i].ProcessHandle, INFINITE);}for(i=0;i<10;i++){if(x[i]==0){GetExitCodeProcess(A[i].ProcessHandle, &ulExitCode);printf("\nThe process %d exit with %d.\n",i, ulExitCode);}}for(i=0;i<10;i++){if(x[1]==0){CloseHandle(A[i].ProcessHandle);CloseHandle(A[i].ThreadHandle);}}if(x[i]!=0){printf("CreateProcess Failed, Error code: 0x%X.\n", GetLastError());nResult = 1;}return nResult;}3. 需要解决的问题及解答（1）.在PsCreateProcess 函数中调用了PspCreateProcessEnvironment 函数后又先后调用了PspLoadProcessImage 和PspCreateThread 函数，学习这些函数的主要功能。

操作系统上机实验报告实验名称：进程和线程实验目旳：理解unix/Linux下进程和线程旳创立、并发执行过程。

实验内容：1．进程旳创立2．多线程应用实验环节及分析：一、进程旳创立下面这个C程序展示了UNIX系统中父进程创立子进程及各自分开活动旳状况。

fork( )创立一种新进程。

系统调用格式：pid=fork( )参数定义：int fork( )fork( )返回值意义如下：0：在子进程中，pid变量保存旳fork( )返回值为0，表达目迈进程是子进程。

>0：在父进程中，pid变量保存旳fork( )返回值为子进程旳id值（进程唯一标记符）。

-1：创立失败。

如果fork( )调用成功，它向父进程返回子进程旳PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。

此时OS在内存中建立一种新进程，所建旳新进程是调用fork( )父进程（parent process）旳副本，称为子进程（child process）。

子进程继承了父进程旳许多特性，并具有与父进程完全相似旳顾客级上下文。

父进程与子进程并发执行。

2、参照程序代码/*process.c*/#include <stdio.h>#include <sys/types.h>main(int argc,char *argv[]){int pid;/* fork another process */pid = fork();if (pid < 0) { /* error occurred */fprintf(stderr, "Fork Failed");exit(-1);}else if (pid == 0) { /* child process */execlp( "/bin/ls", "ls",NULL);}else {/* parent process *//* parent will wait for the child to complete */ wait(NULL);printf( "Child Complete" );exit(0);}}3、编译和运营$gcc process.c –o processs4、运营$./process编辑如图所示：运营如图所示：思考：（1）系统是如何创立进程旳？1,申请空白PCB（进程控制块）；2,为新进程分派资源；3,初始化PCB；4,将新进程插入就绪队列；（2）扩展程序，在父进程中输出1到5，在子进程中输出6-10，规定父子进程并发输出；记录实验成果，并给出简朴分析。

操作系统课程设计报告时间：2015-12-28 〜2013-1-8地点：信息技术实验中心计算机科学与技术专业2013 级2 班07 号2015-12-28目录一．课程设计的目的和意义 (3)二进程调度算法模拟 (4)1 设计目的 (4)2 设计要求 (4)3 使用动态优先权的进程调度算法的模拟 (6)4. ............................................................................................................................................ 程序流程图 (10)5. ............................................................................................................................................ 实验结果 .. (11)6. ............................................................................................................................................ 实验代码 .. (14)7. ............................................................................................................................................ 实验总结 .. (20)三动态分区分配方式模拟 (21)1 设计目的 (21)2 设计要求 (21)3 模拟算法的实现 (21)4 程序流程图 (24)5 实验结果 (24)6 实验代码 (25)7.实验总结 (30)四请求调页存储管理方式模拟 (31)1 设计目的 (31)2 设计要求 (31)3 模拟算法的实现 (32)4 程序流程图 (37)5. ............................................................................................................................................ 实验结果 .. (38)6. ............................................................................................................................................ 实验代码 .. (39)7. ............................................................................................................................................ 实验总结 .. (42)五简单文件系统的实现 (43)1 设计目的 (43)2 设计要求 (43)3 算法的实现 (44)4.程序流程图 (46)5．实验结果 (46)6 实验代码 (47)7.实验总结 (61)操作系统课程设计总结 (62)课程设计的目的和意义目的：1. 根据课堂讲授内容，学生做相应的自主练习，消化课堂所讲解的内容。

实验一进程的创建与并发执行一、实验目的：(1) 熟悉Linux工作环境、文本编辑器工具和GCC工具(2) 加深对进程概念的理解，明确进程和程序的区别(3) 进一步认识并发进程的实质和特征二、实验仪器及材料：微型计算机、Linux系统三、实验内容：1、任务1：进程创建编写一段程序，让父进程产生两个子进程，父进程显示字符“a”、两个子进程，分别显示字符“b”、“c”。

任务2：将上述的输出字符改为输出较长的字符串，观察进程并发执行，分析执行结果。

2、源代码：任务1：#include <stdio.h>main(){int p1, p2;while ((p1=fork())==-1); /*父进程创建第一个进程，直到成功*/if (p1==0) /*0返回给子进程1*/printf(“b\n”); /*P1的处理过程*/else /*正数返回给父进程(子进程号)*/{while ((p2=fork())==-1); /*父进程创建第二个进程，直到成功*/if (p2==0) /* 0返回给子进程2*/printf(“c\n”); /*P2的处理过程*/else printf(“a\n”); /*P2创建完成后，父进程的处理过程*/}}任务2：#include <stdio.h>main(){int p1, p2;while ((p1=fork())==-1); /*父进程创建第一个进程，直到成功*/if(p1==0)while (1)printf(“A ”)else {while ((p2=fork())==-1); /*父进程创建第二个进程，直到成功*/if (p2==0)while (1)printf(“B ”)else /*P2创建完成后，父进程的处理过程*/while (1)printf(“P ”);}}四、实验结果记录：任务1：任务2：五、思考题及解答：1、当新创建进程开始执行时，指令指针的起始位置在创建此进程对应地址的下一个地址。

实验题目进程的创建小组合作否姓名班级学号一、实验目的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、实验目的1.理解PCB2.理解进程的并发执行3.理解进程的FCFS、动态优先权和时间片轮转三种调度算法，并模拟实现这三种算法2、实验器材微型计算机、fedora版本的Linux系统3、实验容PCB在本设计中的基本结构Typedef struct node{Char name[10]；/*进程标识符*/Float prin；/*进程的优先级*/Int round；/*进程轮转的时间片*/Int needtime；/*进程还需要的cpu时间*/Int waittime；/*进程进入系统后等待cpu的时间*/Char state；/*进程的状态*/Struct node *next；/*指针*/}PCB设计三个队列：就绪、完成、运行，其中运行队列中应该只有一个进程。

创建进程，就是用户输入进程的标识符和运行所需时间，系统为其生成一个PCB，存放进程的信息，将新生成的PCB插入就绪队列。

进程任务结束，系统将其PCB插入完成队列，该进程就消亡。

任务1：动态优先权调度算法模拟：优先权= 1 + 等待时间/需要服务时间----最高响应比优先(1) 输入一批作业的进程标识和估计运行时间，将其PCB插入就绪队列(2) 当就绪队列非空、CPU空闲时，计算出每个就绪进程的优先权(3) 将优先权最高的进程从就绪队列移入运行队列，状态改为运行(模拟进程调度)(4) 在屏幕上输出当前所有进程的状态和优先权信息(已完成进程不显示)(5) 让运行进程执行足够的服务时间(6) 将运行进程移入完成队列(7) 提示可以输入新的作业，如果有新作业输入，则转向(1) ，否则转向(2)(8) 如果就绪队列为空，则结束程序框图如下：程序源代码如下：#include <stdio.h>#include <string.h>typedef struct node{char name[10]; //进程标识符float prin; //进程的优先级int round; //进程轮转的时间片int needtime; //进程还需要当CPU时间int waittime; //进程进入系统后等待当CPU的时间char state; //进程当状态struct node *next; //指针} PCB;PCB *readyQueue=NULL, *runningQueue=NULL,*finishedQueue=NULL, *finishedQueueT ail=NULL,*readyQueueT ail=NULL, pcbPool[10];int poolSize = 0;void createPro(); //根据进程标识和估计运行时间，将其PCB插入就绪队列void readyQueueNotNull(); //当就绪队列非空、CPU空闲时，计算每个就绪进程当优先权void insertRunningQueue(); //将优先权最高当进程从就绪队列移入运行队列，状态改为运行void displayQueue(); //将所有非结束进程的状态和优先权信息显示在屏幕void runPro(); //让运行进程执行足够的服务时间void addNewPro(); //提示可以输入新的进程int main(int argc, char const *argv[]){createPro();while(readyQueue!=NULL){readyQueueNotNull();insertRunningQueue();displayQueue();runPro();puts("");addNewPro();}puts("Bye");return 0;}void createPro(){char name[10];char stop = 'y';int needtime, i=0;while(stop=='y'){//获取用户输入进程名puts("Please input the process name: ");scanf("%s", name);strcpy(pcbPool[i].name, name);//获取用户输入进程需要时间puts("Please input the need of time: ");scanf("%d", &needtime);pcbPool[i].needtime = needtime;pcbPool[i].state = '0';pcbPool[i].next = NULL;pcbPool[i].prin = 0.0f;pcbPool[i].waittime = 0;if(i==0){readyQueue = &pcbPool[0];readyQueueT ail = &pcbPool[0];} else {readyQueueT ail->next = &pcbPool[i];readyQueueT ail = &pcbPool[i];}if(i++ > 9)break;puts("Do you want to input more process(y or n): ");scanf("%s", &stop);}poolSize = i + 1;}void readyQueueNotNull(){PCB *pcb = readyQueue;while(1){pcb->prin = 1 + pcb->waittime / pcb->needtime;if(pcb->next==NULL)break;elsepcb = pcb->next;}}void insertRunningQueue(){PCB *currentPCB = readyQueue, *lastPCB = readyQueue,*lastOfChosePCB = readyQueue, *chosePCB = readyQueue;while(1){//选择优先级最高的进程if(currentPCB->prin < currentPCB->prin){lastOfChosePCB = lastPCB;chosePCB = currentPCB;}//判断就绪队列是否判断结束if(currentPCB->next!=NULL){lastPCB = currentPCB;currentPCB = currentPCB->next;} else {break;}}chosePCB->state = '1'; //将优先级最高的进程状态标识为运行时runningQueue = chosePCB; //将优先级最高的进程从就绪队列移入运行队列//将优先级最高的进程从就绪队列中移出if(readyQueue==chosePCB)readyQueue = readyQueue->next;elselastOfChosePCB->next = chosePCB->next;}void displayQueue(){if(readyQueue!=NULL){PCB pcb = *readyQueue;while(1){printf("Process: %s State: %d prin: %f\n", , pcb.state, pcb.prin);if(pcb.next==NULL)break;elsepcb = *(pcb.next);}}if(runningQueue!=NULL)printf("Process: %s State: %d prin: %f\n", runningQueue->name, runningQueue->state, runningQueue->prin);}void runPro(){sleep(runningQueue->needtime);if(readyQueue!=NULL){PCB *pcb = readyQueue;while(1){pcb->waittime = pcb->waittime +runningQueue->needtime;if(pcb->next==NULL)break;elsepcb = pcb->next;}}//将运行了需要时间的进程移入完成队列if(finishedQueue==NULL){finishedQueue = runningQueue;finishedQueueTail = runningQueue;finishedQueueTail->next = NULL;} else {finishedQueueTail->next = runningQueue;finishedQueueTail = runningQueue;}//清理运行时队列runningQueue->state = '0';runningQueue = NULL;}void addNewPro(){char name[10];char stop = 'y';int needtime, i=poolSize-1;puts("Do you want to input more process(y or n): ");scanf("%s", &stop);while(stop=='y'){//获取用户输入进程名puts("Please input the process name: ");scanf("%s", name);strcpy(pcbPool[i].name, name);//获取用户输入进程需要时间puts("Please input the need of time: ");scanf("%d", &needtime);pcbPool[i].needtime = needtime;pcbPool[i].state = '0';pcbPool[i].next = NULL;pcbPool[i].prin = 0.0f;pcbPool[i].waittime = 0;if(readyQueue==NULL){readyQueue = &pcbPool[i];readyQueueT ail = &pcbPool[i];} else {readyQueueT ail->next = &pcbPool[i];readyQueueT ail = &pcbPool[i];}if(i++ > 9)break;elseputs("Do you want to input more process(y or n): ");scanf("%s", &stop);}poolSize = i + 1;}程序运行截图如下：任务2：时间片轮转调度算法模拟输入一批作业的进程标识和估计运行时间，由其PCB组成就绪队列。

实验五进程的并发执行实验目的1、理解并发进程的基本概念和执行特征；2、理解进程的资源继承和并发执行；3、理解进程的资源竞争和互斥实现。

实验原理1．用到的系统调用(1) 创建子进程fork( )pid=fork( )pid==-1：进程创建失败pid==0：子进程创建成功并且执行子进程pid>0：子进程创建成功并且执行父进程(2) 进程终止 exit(int status)父进程在子进程末尾置exit(0)终止子进程，子进程向父进程发软中断信号。

status是子进程返回给父进程的整数，以备查考(3) 进程等待 wait(int status)父进程通过wait(0)等待子进程终止，直到收到子进程发来的进程终止软中断信号后被唤醒。

(4) 进程互斥 lockf(fd,function,size)fd：被锁定的文件标识stdin==0stdout==1function：对锁定对象的控制0：开锁1：加锁size==0：表示从调用Lockf( )后开始锁定实验设备一台电脑以及Linux系统结果预测(1)进程的资源继承A：Before fork…SonBefore fork…FatherB：Before fork…SonFathe(2)进程的并发执行AAACCCBBB……BBAAACCC……(3) 进程的并发控制代码A：daughter1Daughter2……Children1Children2……代码B： son…daughter……….son…children……(4) 进程的多次创建程序A输出6个test；程序B输出14个test。

实验步骤实验结果(1) 进程的资源继承(2) 进程的并发执行(3) 进程的并发控制(4) 进程的多次创建仙女屋实验分析（1）printf某些内容时，操作系统仅仅是把该内容放到了stdout的缓冲队列里，并没有实际显示到屏幕上。

因此fork后，子进程得到这份拷贝。

而当printf中含有\n时，printf将刷新stdout，因此子进程无法得到这份拷贝，fork 也就只输出一次了。

重庆交通大学综合性设计性实验报告班级：计科专业2010级四班*名：***实验项目名称：模拟进程并发执行实验项目性质：操作系统多任务实验所属课程：计算机操作系统实验室(中心)：语音大楼8 楼801 ****：**实验完成时间：2012 年11 月 4 日一、实验目的1、通过实验来模拟进程的并发执行，来深入了解什么事操作系统的进程，以及进程有些什么特性。

2、了解进程间是如何做到并发执行的，进程间是如何做到资源共享的。

以及验证进程在运行过程中的进度是随机的，不可控制的。

3、通过实验来了解进程的三种状态以及状态间的转换条件。

4、加深对进程概念的理解；5、认识进程并发执行的实质6、分析进程争用资源的现象，学习解决进程互斥的方法。

二、实验内容及要求用直观的方式模拟进程执行时的过程，显示在屏幕上。

实现一个能够直观反应单个进程执行与多个进程并发执行时由于资源竞争而引起的进程执行速度变化的过程。

且进程的初始状态和进度都是随机的，不可控制的。

三、实验设备PC机1台、JCreator LE开发环境四、设计方案㈠设计主要思想(1)、每个进程能够随机暂停和开始。

(2)、用Java的多线程来实现。

模拟多线程并发性。

通过进度条来表示进程的运行，通过进度条的运行速度来表示程序的运行速度。

而要体现多进程并发，所以需要在实验中至少定义两个以上的进程，在实验中定义3个进程并发执行。

为了使3个进程的属性和调度方法都是顺利执行，则可以通过三个进程类来分别控制进程对象。

进程的启动时进程的速度是随机性。

要模拟这样一个效果，则可以使用一个随机数对象产生一个随机的数来定义进程运行的位置。

而某个进程的运行速度也是随机的，由进程获得资源的多少来实现。

㈡设计的主要步骤本实验用java语言实现（1）在Jcreator中新建一个ThreadProcess类，分别建立三个公共的线程类，Thread1，Thread2，Thread3.（2）在ThreadProcess类的主函数啊中新建三个线程和和窗口。

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

2. 掌握进程的创建、调度、同步和通信的基本原理。

3. 通过实验演示进程系统的运行过程，加深对进程管理的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发工具：gcc三、实验内容1. 进程的创建2. 进程的调度3. 进程的同步4. 进程的通信四、实验步骤1. 进程的创建（1）编写一个主函数，作为父进程；（2）在父进程中，使用fork()系统调用创建子进程；（3）输出父进程和子进程的进程号、父进程号和子进程号。

2. 进程的调度（1）使用进程调度算法（如FIFO、时间片轮转）对进程进行调度；（2）设置进程的优先级，实现进程的动态调度；（3）输出进程的调度结果，包括进程名、进程号、优先级和调度时间。

3. 进程的同步（1）使用互斥锁（mutex）实现进程的互斥访问；（2）使用条件变量（condition variable）实现进程的同步；（3）输出进程同步的结果，包括互斥锁的使用情况和条件变量的等待/唤醒情况。

4. 进程的通信（1）使用管道（pipe）实现进程间的数据传递；（2）使用共享内存（shared memory）实现进程间的数据共享；（3）输出进程通信的结果，包括管道和共享内存的使用情况。

五、实验结果与分析1. 进程的创建实验结果：成功创建父进程和子进程，输出进程号、父进程号和子进程号。

分析：通过fork()系统调用，父进程创建子进程，子进程继承父进程的代码段和数据段。

2. 进程的调度实验结果：根据进程调度算法，输出进程的调度结果，包括进程名、进程号、优先级和调度时间。

分析：通过设置进程优先级和调度算法，实现进程的动态调度，提高系统资源利用率。

3. 进程的同步实验结果：成功实现互斥锁和条件变量的使用，输出进程同步的结果。

分析：通过互斥锁和条件变量，实现进程的同步访问和条件等待，保证数据的一致性和进程的同步。

4. 进程的通信实验结果：成功使用管道和共享内存实现进程间的数据传递和共享。

操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理和关键机制，包括进程管理、内存管理、文件系统以及设备管理等方面。

同时，培养我们解决实际问题的能力，提高对操作系统相关知识的综合运用水平。

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

三、实验内容及步骤（一）进程管理实验1、进程创建与终止在 Windows 系统中，使用 C+＋语言编写程序，通过调用系统 API函数创建新的进程，并观察进程的创建和终止过程。

在 Linux 系统中，使用 C 语言编写程序，通过 fork(）系统调用创建子进程，并通过 wait(）函数等待子进程的终止。

2、进程调度观察Windows 和Linux 系统中进程的调度策略，包括时间片轮转、优先级调度等。

通过编写程序模拟进程的执行，设置不同的优先级和执行时间，观察系统的调度效果。

（二）内存管理实验1、内存分配与释放在 Windows 系统中，使用 C+＋语言的 new 和 delete 操作符进行内存的动态分配和释放，并观察内存使用情况。

在 Linux 系统中，使用 C 语言的 malloc(）和 free(）函数进行内存的分配和释放，通过查看系统的内存使用信息来验证内存管理的效果。

2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制，包括页表、地址转换等。

通过编写程序访问虚拟内存地址，观察系统的处理方式和内存映射情况。

（三）文件系统实验1、文件操作在 Windows 和 Linux 系统中，使用编程语言对文件进行创建、读取、写入、删除等操作。

观察文件的属性、权限设置以及文件在磁盘上的存储方式。

2、目录操作实现对目录的创建、删除、遍历等操作。

研究目录结构和文件路径的表示方法。