操作系统实验-第二讲、进程的创建
操作系统
实验报告
哈尔滨工程大学
计算机科学与技术学院
第三讲进程的创建
一、实验概述
1. 实验名称
进程的创建
2. 实验目的
1）、练习使用 EOS API 函数 CreateProcess 创建一个进程，掌握创建进程的方法，理解进程和程序的区别。
2）、调试跟踪 CreateProcess 函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。
3. 实验类型（验证、设计）
验证型
4. 实验内容
1）、准备实验
2）、练习使用控制台命令创建 EOS 应用程序的进程
3）、练习通过编程的方式让应用程序创建另一个应用程序的进程
4）、调试 CreateProcess 函数
5）、调试 PsCreateProcess 函数
6）、练习通过编程的方式创建应用程序的多个进程
二、实验环境
进行实验使用的操作系统、编译器、语言及工具等。
操作系统：Windows XP
编译器： Tevalaton OS Lab
语言： C++
三、实验过程（每次实验不一定下面6条都写，根据实际情况定）
*需要解决的问题以及解答
（1）、程序创建2个进程创建的情况下，实验指导P133-4的*NewProcess和6的*ProcessObject变化情况，监控变量界面截图。
答：
在PsCreateProcess函数中找到调用PspCreateProcessEnvironment函数的代码行（create.c文件的163行），并在此行添加一个断点。按 F5继续调试，到此断点处中断。按F11调试进入 PspCreateProcessEnvironment 函数。
在调用ObCreateObject函数的代码行（create.c文件的第418行）添加一个断点。按F5继续调试，到此断点处中断。按F10执行此函数后中断。
将表达式*NewProcess添加到“监视”窗口中,继续一步步调试可以观察到进程控制块的成员变量的值的变化，如下图：
接下来调试初始化进程控制块中各个成员变量的过程：
当从 PspCreateProcessEnvironment 函数返回到 PsCreateProcess 函数后，停止按 F10。此时“监视”窗口中已经不能再显示表达式*NewProcess 的值了，在PsCreateProcess 函数中是使用ProcessObject 指针指向进程控制块的，所以将表达式*ProcessObject 添加到“监视”窗口中就可以继续观察新建进程控制块中的信息。接下来继续使用F10一步步调试 PsCreateProcess 函数中的代码，同样要注意进程控制块中的成员变量的变化：
（2）、尝试根据之前PsCreateProcess 函数和PspCreateProcessEnvironment 函数执行过程的跟踪调试，绘制一幅进程创建过程的流程图。
答：
（3）、思考与练习,在源代码文件NewTwoProc.c 提供的源代码基础上进行修改，要求使用hello.exe 同时创建10个进程。要给出源代码及解释和运行界面截图。
答：
1）. 设计思路
创建10个进程时，可以使用 PROCESS_INFORMATION 类型定义一个有 10 个元素的数组，每一个元素对应一个进程。使用一个循环创建 10
个子进程，然后再使用一个循环等待 10 个子进程结束，得到退出码后
关闭句柄。
2）. 算法实现
在创建10个进程的程序中，为了保证只有在10个进程都创建成功的情况下才执行后续操作，引入一个变量flag，只有10个程序都创建
成功时flag=1，出现创建失败的情况时flag=0，当flag=1时再执行后
续操作。否则直接关闭已创建的进程并退出系统。
附实现代码：
#include "EOSApp.h"
STARTUPINFO StartupInfo;
PROCESS_INFORMATION my_process[10];
ULONG ulExitCode; //子进程退出码
INT nResult=0; //main函数返回值。0表示成功，非0表示失败。
#ifdef _DEBUG
__asm("int $3\n nop");
#endif
printf("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 i;
int flag = 1;
int cnt = 0;
for(i=0; i<10; i++) {
//Create ten processes at the same time
if(CreateProcess("A:\\Hello.exe", NULL, 0, &StartupInfo, &my_process[i])) //if ok jump
cnt++;
else {
//else output error
printf("CreateProcess Failed,Error code:0x%X.\n", GetLastError());
nResult = 1;
flag = 0;
break;
//if flag == 0 there must be some error
}
}
if(flag == 1){
//创建子进程成功，等待子进程运行结束。
for(i=0; i<10; i++) {
WaitForSingleObject(my_process[i].ProcessHandle, INFINITE);
}
//得到并输出子进程的退出码。
for(i=0; i<10; i++){
GetExitCodeProcess(my_process[i].ProcessHandle,
&ulExitCode);
printf("\nThe process%d exit with%d.\n", i+1, ulExitCode);
}
//关闭不再使用的句柄。
for(i=0; i<10; i++) {
CloseHandle(my_process[i].ProcessHandle);
CloseHandle(my_process[i].ThreadHandle);
}
} else {
for( ; cnt>0; cnt--) {
GetExitCodeProcess(my_process[cnt].ProcessHandle,
&ulExitCode);
printf("\nThe process%d exit with%d.\n", i+1, ulExitCode);
CloseHandle(my_process[cnt].ProcessHandle);
CloseHandle(my_process[cnt].ThreadHandle);
}
}
return nResult;
}
（4）、学习本书第 5 章中的 5.2 节，了解关于线程的相关知识，然后尝试调试 PspCreateThread 函数，观察线程控制块（TCB）初始化的过程。
（5）、在 PsCreateProcess 函数中调用了 PspCreateProcessEnvironment 函数后又先后调用了PspLoadProcessImage 和 PspCreateThread 函数，学习这些函数的主要功能。能够交换这些函数被调用的顺序吗？思考其中的原因。
答：
PspCreateProcessEnvironment创建了地址空间和分配了句柄表。PspLoadProcessImag是将进程的可执行映像加载到了进程的地址空间中。PspCreateThread创建了进程的主线程。这三个函数知道自己要从哪里开始执行，执行哪些指令。因此不能交换他们的顺序。
*程序运行时的初值以及运行结果：
3.1 准备实验
建立一个EOS Kernel 项目和 EOS 应用程序项目。
3.2 练习使用控制台命令创建 EOS 应用程序的进程
将本实验文件夹中的Hello.exe文件拖动到FloppyImageEditor工具窗口的文件列表中释放，Hello.exe文件即被添加到软盘镜像文件中，按F5启动调试，在EOS的控制台中输入命令“A:\Hello.exe”后回车，结果如下图：
3.3 练习通过编程的方式让应用程序创建另一个应用程序的进程
使用 NewProc.c 文件中的源代码替换之前创建的 EOS 应用程序项目中的 EOSApp.c 文件内的源代码，F5 启动调试，激活虚拟机窗口查看应用程序输出的内容：
3.4 调试 CreateProcess 函数
F5 启动调试 EOS 应用程序，在 main 函数中调用 CreateProcess 函数的代码行（第 57 行）添加一个断点。按 F5 继续调试，在断点处中断。按F11 调试进入 CreateProcess 函数。在“调试”菜单的“窗口”中选择
“反汇编”，会在“反汇编”窗口中显示 CreateProcess 函数的指令对应的反汇编代码。“反汇编”窗口的左侧显示的是指令所在的虚拟地址。可以看到所有指令的虚拟地址都大于 0x80000000，说明内核（ kernel.dll）处于高 2G 的虚拟地址空间中,如图：
设置 main 函数的调用堆栈帧为活动的。在“反汇编”窗口中查看 main 函数的指令所在的虚拟地址都是小于0x80000000，说明应用程序（eosapp.exe）处于低2G 的虚拟地址空间中，如图：
3.5 调试 PsCreateProcess 函数
已在需要解决的问题以及解答中给出过程
3.6 练习通过编程的方式创建应用程序的多个进程
用 NewTwoProc.c 文件中的源代码替换 EOS 应用程序项目中 EOSApp.c 文件内的源代码，生成后启动调试，查看多个进程并发执行的结果。
四、实验体会
本次实验主要练习使用EOS API函数 CreateProcess创建一个进程，掌握创
建进程的方法，理解进程和程序的区别。以及调试跟踪 CreateProcess函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。通过本次实验了解了了解操作系统中进程与线程的区别。通过对进程以及线程进行不同的创建方式，观察启动之后的区别，从而理解操作系统启动后的工作方式。通过一步步的操作，加深了在操作系统上对进程与线程的创建、调试程序的掌握，但对OS的相关知识还不是很了解。
计算机操作系统进程调度实验研究报告
计算机操作系统进程调度实验研究报告
————————————————————————————————作者：————————————————————————————————日期：
操作系统实验题：设计一若干并发进程的进程调度程序 一、实验目的 无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 二、实验要求 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解． 三、实验内容 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。 四、实验算法流程
实验二(1)进程同步
实验二（2）进程同步 一、实验目的 1、生产者-消费者问题是很经典很具有代表性的进程同步问题，计算机中的很多同步问题都可抽象为生产者-消费者问题，通过本实验的练习，希望能加深学生对进程同步问题的认识与理解。 2、熟悉VC的使用，培养和提高学生的分析问题、解决问题的能力。 二、实验内容及其要求 1．实验内容 以生产者/消费者模型为依据，创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则；设计程序，实现生产者/消费者进程(线程)的同步与互斥； 三、实验算法分析 1、实验程序的结构图（流程图）； 2、数据结构及信号量定义的说明； (1) CreateThread ●功能——创建一个在调用进程的地址空间中执行的线程 ●格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, DWORD dwCreationFlags, Lpdword lpThread ); ●参数说明 lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。dwStackSize——定义原始堆栈大小。 lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。 lpParamiter——定义一个给进程传递参数的指针。 dwCreationFlags——定义控制线程创建的附加标志。 lpThread——保存线程标志符(32位) (2) CreateMutex ●功能——创建一个命名或匿名的互斥量对象 ●格式 HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName); bInitialOwner——指示当前线程是否马上拥有该互斥量(即马 ●参数说明 lpMutexAttributes——必须取值NULL。上加锁)。 lpName——互斥量名称。 (3) CreateSemaphore ●功能——创建一个命名或匿名的信号量对象 ●格式 HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCTSTR lpName ); ●参数说明 lpSemaphoreAttributes——必须取值NULL。
进程管理实验报告
实验2过程管理实验报告学生号姓名班级电气工程系过程、过程控制块等基本原理过程的含义：过程是程序运行过程中对数据集的处理，以及由独立单元对系统资源的分配和调度。在不同的数据集上运行程序，甚至在同一数据集上运行多个程序，是一个不同的过程。（2）程序状态：一般来说，一个程序必须有三种基本状态：就绪、执行和阻塞。然而，在许多系统中，过程的状态变化可以更好地描述，并且增加了两种状态：新状态和终端状态。1）就绪状态，当一个进程被分配了除处理器（CPU）以外的所有必要资源时，只要获得了处理器，进程就可以立即执行。此时，进程状态称为就绪状态。在系统中，多个进程可以同时处于就绪状态。通常，这些就绪进程被安排在一个或多个队列中，这些队列称为就绪队列。2）一旦处于就绪状态的进程得到处理器，它就可以运行了。进程的状态称为执行状态。在单处理器系统中，只有一个进程在执行。在多处理器系统中，可能有多个进程在执行中。3）阻塞状态由于某些事件（如请求输入和输出、额外空间等），执行进程被挂起。这称为阻塞状态，也称为等待状态。通常，处于阻塞状态的进程被调度为-？这个队列称为阻塞队列。4）新状态当一个新进程刚刚建立并且还没有放入就绪队列中时，它被称为新状态。5）终止状态是
什么时候-？进程已正常或异常终止，操作系统已将其从系统队列中删除，但尚未取消。这就是所谓的终结状态。（3）过程控制块是过程实体的重要组成部分，是操作系统中最重要的记录数据。控制块PCB记录操作系统描述过程和控制过程操作所需的所有信息。通过PCB，一个不能独立运行的程序可以成为一个可以独立运行的基本单元，并且可以同时执行一个进程。换句话说，在进程的整个生命周期中，操作系统通过进程PCB管理和控制并发进程。过程控制块是系统用于过程控制的数据结构。系统根据进程的PCB来检测进程是否存在。因此，进程控制块是进程存在的唯一标志。当系统创建一个进程时，它需要为它创建一个PCB；当进程结束时，系统回收其PCB，进程结束。过程控制块的内容过程控制块主要包括以下四个方面的信息。过程标识信息过程标识用于对过程进行标识，通常有外部标识和内部标识。外部标识符由流程的创建者命名。通常是一串字母和数字。当用户访问进程时使用。外部标识符很容易记住。内部标识符是为了方便系统而设置的。操作系统为每个进程分配一个唯一的整数作为内部标识符。通常是进程的序列号。描述性信息（process scheduling message）描述性信息是与流程调度相关的一些有关流程状态的信息，包括以下几个方面。流程状态：表
操作系统实验1
#include "stdio.h" #include
操作系统实验-进程控制
实验一、进程控制实验 1.1 实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法，了解父子进程间的控制和协作关系。练习Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。 1.2 实验说明 1）与进程创建、执行有关的系统调用说明进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过exec()系统调用族装入一个新的执行程序。父进程可以使用wait()或waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。 fork()系统调用语法: #include
Exec 执行成功后将用一个新的程序代替原进程，但进程号不变，它绝不会再返回到调用进程了。如果exec 调用失败，它会返回-1。 wait() 系统调用语法: #include
os实验二 进程同步
实验二：进程同步 一．实验目的 （1）掌握基本的同步算法，理解生产者消费者模型。 （2）学习使用Windows XP中基本的同步对象，掌握相关API的使用方法。 （3）了解Windows XP中多线程的并发执行机制，实现进程的同步与互斥。 二．实验属性 该实验为设计性实验。 三．实验仪器设备及器材 普通PC386以上微机 四．实验要求 本实验要求2学时完成。 本实验要求完成如下任务： （1）以生产者/消费者模型为依据，在Windows XP环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 学习并理解生产者/消费者模型及其同步/互斥规则； 学习了解Windows同步对象及其特性； 熟悉实验环境，掌握相关API的使用方法； 设计程序，实现生产者/消费者进程(线程)的同步与互斥。 （2）扩展任务2选1： 1>利用信号量机制，写出不会发生死锁的解决哲学家进程(线程)。 最多允许4个同时进餐；奇：先左后右偶：先右后左。 2>利用信号量机制，写出不会发生死锁的读者写者进程(线程)。五：实验内容： 利用至多同时允许4位哲学家同时去拿左边筷子的方法解决进餐死锁的问题。 实验详细设计：流程图:
程序首先创建一个线程参数结构体 struct ThreadInfo { int serial; double delay; }; 设置最多同时去拿筷子的人数#define MAX_BUFFER_NUM 4 设置一个信号量数组用来表示五位哲学家的左右边的筷子HANDLE chopstick [5]; 设置同时去拿筷子的人数的信号量HANDLE People; 设置一个互斥信号量HANDLE h_mutex; 在main()函数中，首先创建信号量： for (int i=0;i<5;i++) { chopstick[i]=CreateSemaphore(NULL,n_Buffer_or_Critical,n_Buffer_or_Criti cal,"chopstick"+i); } People=CreateSemaphore(NULL,MAX_BUFFER_NUM,MAX_BUFFER _NUM,"People");
操作系统实验报告--实验一--进程管理
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
操作系统实验08
实验8 缺页统计 实验目的 学习虚拟内存的基本原理和Linux虚拟内存管理技术；深入理解、掌握Linux的按需调页过程。 复习巩固Linux内核模块和虚拟文件系统的知识和运用能力。 实验原理 由于每发生一次缺页都要进入缺页中断服务函数do_page_fault一次，所以可以认为执行该函数的次数就是系统发生缺页的次数。通过定义一个全局变量pfcount作为计数变量，每次执行do_page_fault时，该变量值加1，从而得到一段时间内的缺页次数。 至于经历的时间则可以利用系统原有的变量jiffies。这是一个系统的计时器，在内核加载完以后开始计时，以10ms（缺省）为计时单位。 借助内核模块技术通过/proc虚拟文件系统来读出上述两个变量的值。在/proc文件系统下建立目录pf以及在该目录下的只读文件pfcount和jiffies。 实验内容 完成《边干边学》第7.3.1节的“系统缺页次数”实验。 1.修改现有的内核代码，在系统中添加一个全局变量pfcount。配置、编译、安装新 的内核，并重新启动，使用新的内核。 2.编辑、编译、安装新的内核模块pf，在/proc虚拟文件系统中创建目录pf以及只 读文件pfcount和jiffies。 3.编写用户程序，引发足够的缺页中断；观察一定时间内的缺页状况。 4.选做：学习《边干边学》第7章，阅读相关的内核源代码，分析Linux系统中缺页 的处理过程。 实验步骤 一、修改现有内核代码，添加缺页计数器pfcount 1．以root帐号登录，解包内核源码，并转入内核源码目录 cd /usr/src tar zxvf linux-2.4.18.tar.gz cd linux 2．修改include/linux/mm.h文件 添加变量pfcount的声明 即添加extern unsigned long volatile pfcount;一行
山东大学操作系统实验报告4进程同步实验
山东大学操作系统实验报告4进程同步实验
计算机科学与技术学院实验报告 实验题目：实验四、进程同步实验学号： 日期：20120409 班级：计基地12 姓名： 实验目的： 加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥 操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。了解 Linux 系统中 IPC 进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。 实验内容： 抽烟者问题。假设一个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料：烟草、纸和胶水。一个抽烟者有烟草，一个有纸，另一个有胶水。系统中还有两个供应者进程，它们无限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这一过程重复进行。请用以上介绍的 IPC 同步机制编程，实现该问题要求的功能。 硬件环境： 处理器：Intel? Core?i3-2350M CPU @ 2.30GHz ×4 图形：Intel? Sandybridge Mobile x86/MMX/SSE2 内存：4G 操作系统：32位 磁盘：20.1 GB 软件环境： ubuntu13.04 实验步骤： （1）新建定义了producer和consumer共用的IPC函数原型和变量的ipc.h文件。
（2）新建ipc.c文件，编写producer和consumer 共用的IPC的具体相应函数。 （3）新建Producer文件，首先定义producer 的一些行为，利用系统调用，建立共享内存区域，设定其长度并获取共享内存的首地址。然后设定生产者互斥与同步的信号灯，并为他们设置相应的初值。当有生产者进程在运行而其他生产者请求时，相应的信号灯就会阻止他，当共享内存区域已满时，信号等也会提示生产者不能再往共享内存中放入内容。 （4）新建Consumer文件，定义consumer的一些行为，利用系统调用来创建共享内存区域，并设定他的长度并获取共享内存的首地址。然后设定消费者互斥与同步的信号灯，并为他们设置相应的初值。当有消费进程在运行而其他消费者请求时，相应的信号灯就会阻止它，当共享内存区域已空时，信号等也会提示生产者不能再从共享内存中取出相应的内容。 运行的消费者应该与相应的生产者对应起来，只有这样运行结果才会正确。
实验二进程管理
实验二进程管理 （一）实验目的或实验原理 1．加深对进程概念的理解，明确进程和程序的区别。 2．进一步认识并发执行的实质。 3．分析进程竞争资源现象，学习解决进程互斥的方法。 4．了解Linux系统中进程通信的基本原理。 （二）实验内容 1．进程的创建。 2．进程的控制。 3．①编写一段程序，使其现实进程的软中断通信。 要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child Processll is Killed by Parent! Child Processl2 is Killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止 Parent Process is Killed! ②在上面的程序中增加语句signal (SIGNAL, SIG-IGN) 和signal (SIGQUIT, SIG-IGN), 观察执行结果，并分析原因。 4．进程的管道通信。 编制一段程序，实现进程的管理通信。 使用系统调用pipe()建立一条管道线；两个子进程P1和P2分别向管道中写一句话： Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。 要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。 实验2 指导 [实验内容] 1．进程的创建 〈任务〉 编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符；父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 〈程序〉 #include<> main() { int p1,p2; if(p1=fork()) /*子进程创建成功*/ p utchar('b'); else { if(p2=fork()) /*子进程创建成功*/
操作系统作业二
1 填空题 1．设单CPU环境下，有三道作业，它们的提交时间及运行时间如下表： 若采用短作业优先调度策略，作业单道串行运行时的调度次序为 J1,J3,J2 ，平均周转时间= 8 。 2．进程间通信的类型有：基于内存通信、基于文件通信、基于网络通信 和基于报文传递通信。 3．在响应比最高者优先的作业调度算法中，当各个作业等待时间相同时，运行时间短作业将得 到优先调度；当各个作业要求运行的时间相同时，等待时间长得到优先调度。 4.有三个同时到达的作业J1，J2和J3，它们的执行时间分别是T1，T2和T3，且T1 C、多个进程竞争，资源出现了循环等待 D、多个进程竞争共享型设备 3．（ C ）不是分时系统的基本特征： A、同时性 B、独立性 C、实时性 D、交互性 4．进程所请求的一次打印输出结束后，将使进程状态从（B D） A、运行态变为就绪态 B、运行态变为等待态 C、就绪态变为运行态 D、等待态变为就绪态 5．一作业进入内存后，则所属该作业的进程初始时处于（ B C）状态。 A、运行 B、等待 C、就绪 D、收容 6．运行时间最短的作业被优先调度，这种企业调度算法是（C ） A．优先级调度 B．响应比高者优先C．短作业优先D．先来先服务 7．产生死锁的主要原因是进程运行推进的顺序不合适（C ） A．系统资源不足和系统中的进程太多B．资源的独占性和系统中的进程太多 C．进程调度不当和资源的独占性D．资源分配不当和系统资源不足 8. B 是指从作业进入系统到作业完成所经过的时间间隔； D 是从作业进入后备队列起，到被调度程序选中时的时间间隔。 A：响应时间；B：周转时间；C：运行时间； D：等待时间；F：触发时间。 9．CPU的调度分为高级、中级和低级三种，其中低级调度是指 C 调度。 A：作业B：交换C：进程 10. 批处理系统的主要缺点是（ B ）。 的利用率不高 B.失去了交互性 C.不具备并行性 D.以上都不是 11. 引入多道程序的目的在于（ B A）。 A.充分利用CPU，减少CPU等待时间 B.提高实时响应速度 C 有利于代码共享，减少主、辅存信息交换量充分利用存储器 12. 在分时系统中，时间片一定，（B ），响应时间越长。 A.内存越多 B.用户数越多 C.后备队列 D.用户数越少 13. 我们如果为每一个作业只建立一个进程，则为了照顾短作业用户，应采用 SJF B ；为照顾紧急作 实验二进程同步演示 一、实验目的 ?深入掌握进程同步机制——信号量的应用； ?掌握Windows编程中信号量机制的使用方法； ?可进行简单的信号量应用编程。 二、实验工具 Windows系统+ VC++ 6.0 三、实验内容 1、复习教材上信号量机制的定义与应用，复习经典进程同步问题——生产者消费者问题及其同步方案； 2、验证后附的参考代码pc.cpp（生产者消费者问题）,掌握Windows系统中信号量的定义与使用方法； 注意： （1）代码中生产者和消费者所做的工作用过程Producer和Consumer描述，并通过创建线程的方法创建3个生产者线程和1个消费者线程，具体创建方法：CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);其中第3个参数就是指定该线程所做的工作为过程Producer； （2）问题中设置了三个信号量g_hMutex（用于互斥访问临界区buffer）、 g_hFullSemaphore、g_hEmptySemaphore（用于控制同步的资源信号量），先声明，再定义，最后使用。互斥信号量和资源信号量的定义方法不同： g_hMutex = CreateMutex(NULL,FALSE,NULL); 互斥信号量最开始没有指定针对那个资源g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL); 其中第2和3个参数为信号量的初始值和最大值 信号量的使用方法：WaitForSingleObject为信号量的P操作，每对一个信号量执行该操作，则信号量值减1，并判断减1后值是否仍大于等于0，如是则该操作成功，否则进程阻塞；ReleaseSemaphore为信号量的V操作，每执行一次将该信号量的值加1，并起到唤醒作用。如： WaitForSingleObject(g_hFullSemaphore,INFINITE); … ReleaseSemaphore(g_hEmptySemaphore,1,NULL); 操作系统实验实验二进程管理 学号 1215108019 姓名克帆 学院信息学院 班级 12电子2 实验目的 1、理解进程的概念，明确进程和程序的区别。 2、理解并发执行的实质。 3、掌握进程的创建、睡眠、撤销等进程控制方法。 实验容与要求 基本要求：用C语言编写程序，模拟实现创建新的进程；查看运行进程；换出某个进程；杀死进程等功能。 实验报告容 1、进程、进程控制块等的基本原理。 进程是现代操作系统中的一个最基本也是最重要的概念，掌握这个概念对于理解操作系统实质，分析、设计操作系统都有其非常重要的意义。为了强调进程的并发性和动态性，可以给进程作如下定义：进程是可并发执行的程序在一个数据集合上的运行过程，是系统进行资源分配和调度的一个独立单位。 进程又就绪、执行、阻塞三种基本状态，三者的变迁图如下： 由于多个程序并发执行，各程序需要轮流使用CPU，当某程序不在CPU上运行时，必须保留其被中断的程序的现场，包括：断点地址、程序状态字、通用寄存器的容、堆栈容、程序当前状态、程序的大小、运行时间等信息，以便程序再次获得CPU时，能够正确执行。为了保存这些容，需要建立—个专用数据结构，我们称这个数据结构为进程控制块PCB （Process Control Block）。 进程控制块是进程存在的惟一标志，它跟踪程序执行的情况，表明了进程在当前时刻的状态以及与其它进程和资源的关系。当创建一个进程时，实际上就是为其建立一个进程控制块。 在通常的操作系统中，PCB应包含如下一些信息： ①进程标识信息。为了标识系统中的各个进程，每个进程必须有惟一的标识名或标 识数。 ②位置信息。指出进程的程序和数据部分在存或外存中的物理位置。 ③状态信息。指出进程当前所处的状态，作为进程调度、分配CPU的依据。 ④进程的优先级。一般根据进程的轻重缓急其它信息。 这里给出的只是一般操作系统中PCB所应具有的容，不同操作系统的PCB结构是不同的，我们将在2.8节介绍Linux系统的PCB结构。 操作系统 实验报告 哈尔滨工程大学 计算机科学与技术学院 一、实验概述 1. 实验名称 进程的同步 2. 实验目的 ⑴使用EOS的信号量，编程解决生产者 消费者问题，理解进程同步的意义。 ⑵调试跟踪EOS信号量的工作过程，理解进程同步的原理。 ⑶修改EOS的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同步的原理。 3. 实验类型 验证+设计 4. 实验内容 ⑴准备实验 ⑵使用EOS的信号量解决生产者－消费者问题 ⑶调试EOS信号量的工作过程 ①创建信号量 ②等待释放信号量 ③等待信号量（不阻塞） ④释放信号量（不唤醒） ⑤等待信号量（阻塞） ⑥释放信号量（唤醒） ⑷修改EOS的信号量算法 二、实验环境 WindowsXP + EOS集成实验环境 三、实验过程 1. 设计思路和流程图 图4-1.整体试验流程图 图4-2.Main 函数流程图、生产者消费、消费者流程图 2. 算法实现 3. 需要解决的问题及解答 (1). 思考在ps/semaphore.c 文件内的PsWaitForSemaphore 和PsReleaseSemaphore 函数中，为什么要使用原子操作？ 答：在执行等待信号量和释放信号量的时候，是不允许cpu响应外部中断的，如果此时cpu响应了外部中断，会产生不可预料的结果，无法正常完成原子操作。 (2). 绘制ps/semaphore.c文件内PsWaitForSemaphore和PsReleaseSemaphore函数的流程图。 (3).P143生产者在生产了13号产品后本来要继续生产14号产品，可此时生产者为什么必须等待消费者消费了4号产品后，才能生产14号产品呢？生产者和消费者是怎样使用同步对象来实现该同步过程的呢？ 答：这是因为临界资源的限制。临界资源就像产品仓库，只有“产品仓库”空闲生产者才能生产东西，有权向里面放东西。所以它必须等到消费者，取走产品，“产品空间”（临界资源）空闲时，才继续生产14号产品。 (4). 根据本实验3.3.2节中设置断点和调试的方法，自己设计一个类似的调试方案来验证消费者线程在消费24号产品时会被阻塞，直到生产者线程生产了24号产品后，消费者线程才被唤醒并继续执行的过程。 答：可以按照下面的步骤进行调试 (1) 删除所有的断点。 (2) 按F5启动调试。OS Lab会首先弹出一个调试异常对话框。 (3) 在调试异常对话框中选择“是”，调试会中断。 (4) 在Consumer函数中等待Full信号量的代码行（第173行）WaitForSingleObject(FullSemaphoreHandle, INFINITE); 添加一个断点。 (5) 在“断点”窗口（按Alt+F9打开）中此断点的名称上点击右键。 (6) 在弹出的快捷菜单中选择“条件”。 (7) 在“断点条件”对话框（按F1获得帮助）的表达式编辑框中，输入表达式“i == 24”。 (8) 点击“断点条件”对话框中的“确定”按钮。 (9) 按F5继续调试。只有当消费者线程尝试消费24号产品时才会在该条件断点处中断。 4. 主要数据结构、实现代码及其说明 修改PsWaitForSemaphore函数 if (Semaphore->Count>0){ Semaphore->Count--; flag=STATUS_SUCCESS; }//如果信号量大于零，说明尚有资源，可以为线程分配 else flag=PspWait(&Semaphore->WaitListHead, Milliseconds); KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。 return flag; }//否则，说明资源数量不够，不能再为线程分配资源，因此要使线程等待 修改PsReleaseSemaphore函数 if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) { 操作系统进程管理实验 实验题目： （1）进程的创建编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。 （2）进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。 （3）编制一段程序，使其实现进程的软中断通信。要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程调用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止：Parent process is killed! 在上面的程序中增加语句signal(SIGINT, SIG_IGN)和signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。 （4）进程的管道通信编制一段程序，实现进程的管道通信。使用系统调用pipe( )建立一条管道线；两个进程P1和P2分别向管道各写一句话：Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。 实验源程序及报告： （1）、进程的创建 #include 实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的sched.h源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码如下： #include else{ pid2 = fork(); if(pid2<0){ fprintf(stderr,"childprocess1 failed"); exit(-1); } else if(pid2 == 0){ printf("c\n"); } else{ printf("a\n"); sleep(2); exit(0); } } return 0; } 结果如下： 分析原因： pid=fork(); 操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！因此，这三个进程哪个先执行，哪个后执行，完全取决于操作系统的调度，没有固定的顺序。 （2）进程的控制 修改已经编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 将父进程的输出改为father process completed 2/11 实验三进程的同步 一、实验目的 1、了解进程同步和互斥的概念及实现方法； 2、更深一步的了解fork()的系统调用方式。 二、实验内容 1、预习操作系统进程同步的概念及实现方法。 2、编写一段源程序，用系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。程序的输出是什么？分析原因。 3、阅读模拟火车站售票系统和实现进程的管道通信源代码，查阅有关进程创建、进程互斥、进程同步的系统功能调用或API，简要解释例程中用到的系统功能或API的用法，并编辑、编译、运行程序，记录程序的运行结果，尝试给出合理的解释。 4、（选做）修改问题2的代码，使得父子按顺序显示字符“a”；“b”、“c”编辑、编译、运行。记录程序运行结果。 三、设计思想 1、程序框架 （1）创建两个子进程：（2）售票系统： （3）管道通信： 先创建子进程，然后对内容加锁，将输出语句存入缓存，并让子进程自己进入睡眠，等待别的进程将其唤醒，最后解锁；第二个子进程也执行这样的过程。父进程等待子进程后读内容并输出。 （4）修改程序（1）：在子进程的输出语句前加上sleep()语句，即等待父进程执行完以后再输出。 2、用到的文件系统调用函数 （1）创建两个子进程：fork() （2）售票系统：DWORD WINAPI Fun1Proc(LPVOID lpPartameter); CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); CloseHandle(hThread1); (HANDLE)CreateMutex(NULL,FALSE,NULL); Sleep(4000)（sleep调用进程进入睡眠状态(封锁), 直到被唤醒）; WaitForSingleObject(hMutex,INFINITE); ReleaseMutex(hMutex); （3）管道通信：pipe(fd)，fd: int fd[2]，其中: fd[0] 、fd[1]文件描述符（读、写）; lockf( fd，function，byte)（fd: 文件描述符；function: 1: 锁定 0:解锁；byte: 锁定的字节数，0: 从当前位置到文件尾）; write(fd，buf，byte)、read(fd，buf，byte) （fd: 文件描述符；buf : 信息传送的源（目标）地址；byte: 传送的字节数）; sleep(5); exit(0); read(fd[0]，s，50) （4）修改程序（1）：fork(); sleep(); 四、调试过程 1、测试数据设计 （1）创建两个子进程：实验二进程同步
操作系统实验二
进程的同步实验报告
操作系统实验二(进程管理)
操作系统-进程管理实验报告
进程同步实验报告
相关文档
- 操作系统实验进程调度算法
- 操作系统进程同步实验报告
- 操作系统实验-进程控制
- (完整word版)操作系统实验进程的通信
- 操作系统实验报告 实验一 进程管理
- 操作系统实验进程通信
- 操作系统实验一模拟进程状态转换
- 操作系统-实验三-进程管理-实验报告
- 山东大学操作系统实验报告4进程同步实验
- 操作系统之进程(生产者---消费者)实验报告
- 操作系统实验报告_进程和线程
- 操作系统实验2进程管理报告
- 计算机操作系统进程调度实验报告
- 操作系统实验实验1
- 操作系统实验进程管理c++
- 操作系统实验三 进程的创建#(精选.)
- 操作系统实验报告----进程管理
- 操作系统进程管理实验报告
- 操作系统实验---进程通信
- 操作系统实验报告进程调度