下载文档原格式
操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。
进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。
本实验报告将介绍进程管理的基本概念、原理和实验结果。
一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。
线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。
进程和线程是操作系统中最基本的执行单位。
2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。
就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。
3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。
常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。
二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。
通过PCB，操作系统可以对进程进行管理和控制。
2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。
进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。
进程的创建和撤销是操作系统中的基本操作之一。
3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。
常见的进程同步与通信机制包括互斥锁、信号量和管道等。
三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。
通过该程序，我们可以观察到不同调度算法对系统性能的影响。
实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 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 等进行文件的创建、读取和写入操作。
进程同步：实验报告1．实验内容(进程的同步)(1) 阅读理解⽰例程序。
(2) 说明⽰例程序是否能适合解决 N 个⽣产者和 1 个消费者问题，并设计实验验证(3) 参照教材修改为 N 个⽣产者和 1 个消费者问题(4) 思考 N 个⽣产者和 M 个消费者问题的解决⽅案(不要求)(5) 利⽤信号量解决同步问题。
2．实验⽬的通过程序模拟及验证⽣产者消费者问题等经典问题，深⼊理解并发中的同步和互斥的概念3．实验原理(1)进程概念：(1.定义：程序的⼀次执⾏过程( 2.三种基本状态 :就绪状态，执⾏状态，阻塞状态(2)进程同步：(1.定义：并发进程在执⾏次序上的协调，以达到有效的资源共享和相互合作，使程序执⾏有可再现性。
( 2.两种形式的制约关系： (⼀：资源共享关系：进程间接制约，需互斥地访问临界资源。
)、(⼆：相互合作关系：进程直接制约)(3.临界资源：⼀次仅允许⼀个进程访问的资源，引起不可再现性是因为临界资源没有互斥访问。
(3)信号量：定义⼀个⽤于表⽰资源数⽬的整型量S，它与⼀般的整型量不同，除初始化外，仅能通过两个标准的原⼦操作 wait(S)和 signal(S)来访问，俗称 P,V操作。
通俗来讲就是⽤P 来访问资源后减去⼀个单位资源，⽤ V 操作来释放⼀个单位资源就是现有资源上加⼀个单位资源。
4．实验内容⼀：说明⽰例程序是否能适合解决 N 个⽣产者和 1 个消费者问题，并设计实验验证答：⽰例程序不能解决多个⽣产者和消费者的问题，它是解决单个消费者和⽣产者的。
如果可以就要修改代码，如“⼆”所说。
⼆：多个消费者和⽣产者的问题⽣产者 1 如上图所⽰：如果要解决多个⽣产者和消费者的问题：第⼀步：分析上图得出了两种关系，分别是异步和同步的关系第⼆步：异步关系的是⽣产者和⽣产者之间的，因为同⼀时刻只能有⼀个⽣产者访问缓冲区，所以我们就可以设置临界资源 .获得临界资源的⽣产者才能把产品放到缓冲区⾥第三步：同步关系有两个，⾸先是⽣产者和缓冲区之间，再是缓冲区和消费者之间。
附件（四）之欧侯瑞魂创作深圳年夜学实验报告课程名称：把持系统实验项目名称：进程（线程）同步及死锁学院：计算机与软件学院专业：计算机科学与技术指导教师：陈说人：学号：班级：实验时间：2015/10/23实验陈说提交时间：2015/11/13教务处制二、方法、步伐：设计解决哲学家就餐问题的并发线程.假定有6个哲学家, 围着圆桌交替地进行思考和进餐；每次进餐时, 必需同时拿到左右两边的两只筷子才华进餐；进餐后, 再放下筷子思考.这是一个典范的同时需要两个资源的例子, 如果申请资源顺序不妥, 可能会引起死锁.本实验设计6个哲学家共享一个相同的线程Philosopher, 既完成线程同步, 又预防死锁发生.实验中采纳了3种预防死锁的方法（摒弃‘环路等候’条件, 摒弃‘请求和坚持’条件, 摒弃‘不剥夺’条件）, 要预防死锁, 只采纳其中的任何一种方法即可. 三．实验过程及内容：(其中：提供有简短说明的法式代码.要求：法式运行正确、符合设计要求.)1.创立工程, 注意勾选Win32 Application, 点击确定2.勾选第三个选项3.创立菜单, 有Eat、About、Exit4.在进程（线程）同步及死锁.cpp中编写代码, 此时代码有“摒弃‘环路等候’条件”、“摒弃‘请求和坚持’条件”、“摒弃‘不剥夺’条件”三种代码, 当检测其中一个时须将其余两个加以注释, 一一检测其对死锁的影响.运行结果：运行前：运行后：5.在运行时可知, 在分别“摒弃‘环路等候’条件”和“摒弃‘不剥夺’条件”的代码时不会呈现死锁, 而使用“摒弃‘请求和坚持’条件”时会发生死锁, 在理论正确前提下, 此种情况说明了代码呈现毛病.⑴摒弃‘环路等候’条件R1=ThreadID;R2=(ThreadID+1)%6;if (ThreadID == 0){R1= (ThreadID+1) % 6;R2= ThreadID;}依据摒弃‘环路等候’条件, 要有至少一位哲学家与其他哲学家拿筷子顺序分歧, 则使第0位(ThreadID = 0)哲学家从右边开始拿筷子, 其他哲学家相反.⑵摒弃‘不剥夺’条件Wait(Mutex);if (ChopstickUsed[R2]){Signal(Mutex);goto ReleaseChopstick;//将左筷子放弃失落}Signal(Mutex);若分配给的哲学家拿不到右筷子, 则将他拿到的左筷子收回.⑶摒弃‘请求和坚持’条件原代码：Wait(Mutex);if((ChopstickUsed[R1])||(ChopstickUsed[R2])){Signal(Mutex);。
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。
同时，实现进程的正常终止和异常终止，并分析其对系统的影响。
2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。
通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。
（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。
（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。
观察文件在磁盘上的存储方式和文件系统的目录结构。
2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。
四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。
（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。
（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。
2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。
（2）创建多个进程，模拟对共享资源的并发访问。
（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。
（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
实验一、进程管理与进程同步一、实验目的了解进程管理的实现方法，理解和掌握处理进程同步问题的方法。
二、实验内容实现银行家算法、进程调度过程的模拟、读者-写者问题的写者优先算法。
实验步骤：理解安全性算法和银行家算法的核心机制：针对3类资源、5个进程的情况，设计相应的数据结构，分别表示每个进程占用各类资源的情况；编程实现安全性算法函数，编制主函数，动态输入资源的占用情况，进程的资源申请，调用安全性函数，实现银行家算法；测试：输入可分配和不可分配的请求，测试系统的正确性。
三、实验环境Windows 2000；Microsoft Visual C++ 6.0四、程序源码与运行结果银行家算法代码：#include "malloc.h"#include "stdio.h"#include "stdlib.h"#define alloclen sizeof(struct allocation)#define maxlen sizeof(struct max)#define avalen sizeof(struct available)#define needlen sizeof(struct need)#define finilen sizeof(struct finish)#define pathlen sizeof(struct path)struct allocation{int value;struct allocation *next;};struct max{int value;struct max *next;};struct available /*可用资源数*/{int value;struct available *next;};struct need /*需求资源数*/{int value;struct need *next;};struct path{int value;struct path *next;};struct finish{int stat;struct finish *next;};int main(){int row,colum,status=0,i,j,t,temp,processtest;struct allocation *allochead,*alloc1,*alloc2,*alloctemp;struct max *maxhead,*maxium1,*maxium2,*maxtemp;struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1; struct need *needhead,*need1,*need2,*needtemp;struct finish *finihead,*finish1,*finish2,*finishtemp;struct path *pathhead,*path1,*path2;printf("\n请输入系统资源的种类数:");scanf("%d",&colum);printf("请输入现时内存中的进程数:");scanf("%d",&row);printf("请输入已分配资源矩阵:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入已分配给进程 p%d 的 %c 种系统资源:",i,'A'+j);if(status==0){allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);alloc1->next=alloc2->next=NULL;scanf("%d",&allochead->value);status++;}else{alloc2=(struct allocation *)malloc(alloclen);scanf("%d,%d",&alloc2->value);if(status==1){allochead->next=alloc2;status++;}alloc1->next=alloc2;alloc1=alloc2;}}}alloc2->next=NULL;status=0;printf("请输入最大需求矩阵:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入进程 p%d 种类 %c 系统资源最大需求:",i,'A'+j);if(status==0){maxhead=maxium1=maxium2=(struct max*)malloc(maxlen);maxium1->next=maxium2->next=NULL;scanf("%d",&maxium1->value);status++;}else{maxium2=(struct max *)malloc(maxlen);scanf("%d,%d",&maxium2->value);if(status==1){maxhead->next=maxium2;status++;}maxium1->next=maxium2;maxium1=maxium2;}}}maxium2->next=NULL;status=0;printf("请输入现时系统剩余的资源矩阵:\n");for (j=0;j<colum;j++){printf("种类 %c 的系统资源剩余:",'A'+j);if(status==0){avahead=available1=available2=(struct available*)malloc(avalen); workhead=work1=work2=(struct available*)malloc(avalen);available1->next=available2->next=NULL;work1->next=work2->next=NULL;scanf("%d",&available1->value);work1->value=available1->value;status++;}else{available2=(struct available*)malloc(avalen);work2=(struct available*)malloc(avalen);scanf("%d,%d",&available2->value);work2->value=available2->value;if(status==1){avahead->next=available2;workhead->next=work2;status++;}available1->next=available2;available1=available2;work1->next=work2;work1=work2;}}available2->next=NULL;work2->next=NULL;status=0;alloctemp=allochead;maxtemp=maxhead;for(i=0;i<row;i++)for (j=0;j<colum;j++){if(status==0){needhead=need1=need2=(struct need*)malloc(needlen); need1->next=need2->next=NULL;need1->value=maxtemp->value-alloctemp->value;status++;}else{need2=(struct need *)malloc(needlen);need2->value=(maxtemp->value)-(alloctemp->value); if(status==1)needhead->next=need2;status++;}need1->next=need2;need1=need2;}maxtemp=maxtemp->next;alloctemp=alloctemp->next;}need2->next=NULL;status=0;for(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(struct finish*)malloc(finilen); finish1->next=finish2->next=NULL;finish1->stat=0;status++;}else{finish2=(struct finish*)malloc(finilen);finish2->stat=0;if(status==1){finihead->next=finish2;status++;}finish1->next=finish2;finish1=finish2;}}finish2->next=NULL; /*Initialization compleated*/status=0;processtest=0;for(temp=0;temp<row;temp++){alloctemp=allochead;needtemp=needhead;finishtemp=finihead;worktemp=workhead;for(i=0;i<row;i++)worktemp1=worktemp;if(finishtemp->stat==0){for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next) if(needtemp->value<=worktemp->value)processtest++;if(processtest==colum){for(j=0;j<colum;j++){worktemp1->value+=alloctemp->value;worktemp1=worktemp1->next;alloctemp=alloctemp->next;}if(status==0){pathhead=path1=path2=(struct path*)malloc(pathlen);path1->next=path2->next=NULL;path1->value=i;status++;}else{path2=(struct path*)malloc(pathlen);path2->value=i;if(status==1){pathhead->next=path2;status++;}path1->next=path2;path1=path2;}finishtemp->stat=1;}else{for(t=0;t<colum;t++)alloctemp=alloctemp->next;finishtemp->stat=0;}}elsefor(t=0;t<colum;t++){needtemp=needtemp->next;alloctemp=alloctemp->next;}processtest=0;worktemp=workhead;finishtemp=finishtemp->next;}}path2->next=NULL;finishtemp=finihead;for(temp=0;temp<row;temp++){if(finishtemp->stat==0){printf("\n系统处于非安全状态!\n"); exit(0);}finishtemp=finishtemp->next;}printf("\n系统处于安全状态.\n"); printf("\n安全序列为: \n");do{printf("p%d ",pathhead->value);}while(pathhead=pathhead->next);printf("\n");return 0;}运行结果：备注：输入数据为P110 银行家算法之例所用数据《计算机操作系统》（第三版）西安电子科技大学出版社银行家算法原理说明：银行家算法是一种最有代表性的避免死锁的算法。
实验二：编程实现经典互斥和同步问题1．实验目的：加深对信号量、PV操作、进程同步和互斥等概念的理解，掌握PV操作的具体实现方法，熟练掌握进程同步和互斥的实现办法，能利用信号量机制解决实际生活中的同步和互斥问题。
2．实验内容（1）、编程实现P操作原语、V操作原语，（2）、用所定义的PV操作解决下面的问题：设学院某教室共有座位30个，任何时刻最多可容纳30名同学进入自习，当教室内人数少于30名时，则教室外等待的同学可立即进入，否则需在外面等待。
把一个欲进入教室自习的同学看作一个进程。
3、实验具体内容和步骤的说明（1）用户进程的定义（2）信号量的定义及初始化（3）PV操作的定义P操作顺序执行下述两个动作：①信号量的值减1，即S=S-1；②如果S≥0，则该进程继续执行(挂入就绪队列)；如果S＜0，则把该进程的状态置为阻塞态，把相应的PCB连入该信号量队列的末尾，并放弃处理机，进行等待（直至其它进程在S上执行V操作，把它释放出来为止）。
（挂入阻塞队列）V操作顺序执行下述两个动作：①S值加1，即S=S+1；②如果S＞0，则该进程继续运行；（直接挂入就绪队列）如果S≤0，则释放信号量队列上的第一个PCB（即信号量指针项所指向的PCB）所对应的进程（把阻塞态改为就绪态），执行V操作的进程继续运行。
从阻塞队列唤醒一个进程，即从阻塞队列删除，挂入就绪队列（4）写出对应的主函数，解决多名同学之间的同步问题提示：设置2个进程队列，一是已经进入教室的，即就绪队列二是等待进入教室的，即阻塞队列程序：#include <stdio.h>#include <stdlib.h>typedef struct node{int name; //进程IDchar state;//进程状态struct node *next;}PCB;int s=3;//资源数PCB *stophead=NULL,*stoptail=NULL,*readyhead=NULL,*readytail=NULL;//阻塞就绪队列头尾指针void block(PCB *q)//无资源尾插入阻塞队列{q->state='B';if(stophead==NULL){stophead=q;stoptail=q;}else{stoptail->next=q;stoptail=q;}}void wakeup()//唤醒阻塞队列头节点尾插入就绪队列{stophead->state='R';if(readyhead==NULL){readyhead=stophead;readytail=stophead;stophead=stophead->next;readytail->next=NULL;}else{readytail->next=stophead;readytail=stophead;stophead=stophead->next;readytail->next=NULL;}}void p(PCB *q)//p操作{s=s-1;if(s<0)//无资源则插入阻塞队列block(q);else//尾插入就绪队列{q->state='R';if(readyhead==NULL){readyhead=q;readytail=q;}else{readytail->next=q;readytail=q;}}}int v(int b)//v操作{PCB *q,*pre;if(readyhead==NULL)//无就绪进程返回{printf(" 无就绪进程!\n\n");return 0;}pre=readyhead;q=readyhead;while(q->name!=b)//寻找就绪队列中v操作节点{if(q->next==NULL)//无当前查找节点{printf(" 查无此就绪进程!\n\n");return 1;}pre=q;q=q->next;//查找成功if(readyhead==readytail)//就绪队列仅有一个节点{readyhead=readytail=NULL;free(q);s=s+1;return 0;}else//就绪队列有多个节点{if(q==readyhead){readyhead=readyhead->next;free(q);//释放节点}else if(q==readytail){readytail=pre;pre->next=NULL;free(q);}else{pre->next=q->next;free(q);}s=s+1;if(s<=0)//如有阻塞进程则唤醒加入就绪队列wakeup();return 1;}}void show()//输出当前所有进程状态{PCB *q;q=readyhead;printf("\n");printf(" ID STATE\n");while(q!=NULL)printf("%5d%5c\n",q->name,q->state);q=q->next;}q=stophead;while(q!=NULL){printf("%5d%5c\n",q->name,q->state);q=q->next;}}void main(void){PCB *q;char a;int b;printf("\n剩余资源数%d ",s);printf("PLEASE INPUT:");scanf("%c %d",&a,&b);getchar();//输入当前操作类型进程ID （如p 1）while(a!='0')// （0 0）退出{if(a=='p')//执行p操作{q=(PCB *)malloc(sizeof(PCB));//进程初始化q->name=b;q->next=NULL;p(q);}else if(a=='v')//执行v操作b=v(b);if(b!=0)show();//显示当前进程状态printf("\n剩余资源数%d ",s);printf("PLEASE INPUT:");scanf("%c %d",&a,&b);getchar();}}。
