下载文档原格式
操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。
进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。
本实验报告将介绍进程管理的基本概念、原理和实验结果。
一、进程管理的基本概念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();}}。
一、实验目的1. 理解死锁的概念和产生条件；2. 掌握死锁的避免、检测和解除方法；3. 通过实验加深对死锁处理策略的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 实验工具：Python内置模块三、实验原理死锁是指多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，这些进程都将无法向前推进。
死锁的产生条件包括：互斥条件、占有和等待条件、非抢占条件、循环等待条件。
四、实验内容1. 死锁的产生与避免2. 死锁的检测与解除五、实验步骤1. 死锁的产生与避免（1）定义进程与资源首先，定义一个进程类，包含进程名、资源需求列表和资源分配列表。
资源类包含资源名和数量。
```pythonclass Process:def __init__(self, name, resource_list, allocation_list): = nameself.resource_list = resource_listself.allocation_list = allocation_listclass Resource:def __init__(self, name, count): = nameself.count = count```（2）创建进程与资源实例创建若干进程和资源实例，并初始化资源数量。
```pythonprocess_list = [Process('P1', ['R1', 'R2'], ['R1', 'R2']),Process('P2', ['R1', 'R2'], ['R1', 'R2']),Process('P3', ['R3', 'R4'], ['R3', 'R4'])]resource_list = [Resource('R1', 2), Resource('R2', 2), Resource('R3', 2), Resource('R4', 2)]```（3）实现死锁避免算法采用银行家算法，判断当前分配情况是否满足安全序列。
实验三：进程同步实验一、实验任务：（1）掌握操作系统的进程同步原理；（2）熟悉linux的进程同步原语；（3）设计程序，实现经典进程同步问题。
二、实验原理：（1）P、V操作PV操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：P（S）：①将信号量S的值减1，即S=S-1；②如果S³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。
V（S）：①将信号量S的值加1，即S=S+1；②如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。
（2）信号量信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。
信号量的值与相应资源的使用情况有关。
当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。
注意，信号量的值仅能由PV操作来改变。
一般来说，信号量S³0时，S表示可用资源的数量。
执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。
而执行一个V操作意味着释放一个单位资源，因此S 的值加1；若S£0，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。
（3）linux的进程同步原语①wait()；阻塞父进程，子进程执行；②#include <sys/types.h>#include <sys/ipc.h>key_t ftok (char*pathname, char proj)；它返回与路径pathname相对应的一个键值。
③int semget(key_t key, int nsems, int semflg)参数key是一个键值，由ftok获得，唯一标识一个信号灯集，用法与msgget()中的key 相同；参数nsems指定打开或者新创建的信号灯集中将包含信号灯的数目；semflg参数是一些标志位。
进程同步问题总结进程同步是计算机科学中一个重要的概念，用于解决多个进程共享资源时可能出现的数据竞争和不一致性的问题。
在并发编程中，正确的进程同步机制对于保证系统的正确性和可靠性至关重要。
本文将总结常见的进程同步问题及其解决方案。
1. 互斥问题：当多个进程共享一个临界资源时，可能会发生互斥问题。
如果一个进程占用了临界资源，其他进程就无法使用该资源，导致资源的浪费和性能下降。
解决方案：（1）锁机制：通过使用锁（如互斥锁、自旋锁、读写锁）来保护临界资源。
一旦某个进程获得了锁，其他进程就需要等待，直到锁被释放。
（2）信号量：通过使用信号量来管理对临界资源的访问。
信号量可以用来限制同时访问资源的进程数量。
2. 死锁问题：当多个进程相互等待其他进程释放资源时，可能会发生死锁问题。
即使每个进程都只需要一个资源，但由于资源的分配不当，导致进程无法继续执行。
解决方案：（1）避免循环等待：对于进程需要的资源排序，使得每个进程按照同一种顺序请求资源，从而避免进程之间出现循环等待的情况。
（2）资源预分配：进程在开始执行之前，请求所有需要的资源。
这样可以避免在执行过程中发生资源竞争导致死锁。
（3）超时机制：设定一个等待时间，如果在该时间内没有获得所需资源，就主动释放已获得的资源，并重新开始执行。
3. 竞争条件问题：当多个进程同时竞争访问共享资源时，可能会出现竞争条件问题。
竞争条件指的是多个进程之间的执行顺序会影响最终的结果。
解决方案：（1）原子操作：通过原子操作来确保对共享资源的访问是原子性的，不可中断的。
例如使用原子锁或原子变量等。
（2）同步工具：使用同步工具，如条件变量、屏障等来协调多个进程的执行顺序，以避免竞争条件的出现。
（3）尽量避免共享数据：如果可能的话，尽量避免多个进程之间共享数据，减少竞争条件的发生。
4. 内存一致性问题：在分布式系统中，不同节点的内存可能存在一致性问题。
当一个进程修改了自己所在节点的内存，并且其他节点也有相应的副本时，就可能会出现读取到不一致数据的问题。
操作系统实验报告完成人姓名：李国鹏学号：201258503210报告时间：2014.11一、实验内容编写一段程序，使其现实进程的软中断通信。
要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child Processll is Killed by Parent!Child Processl2 is Killed by Parent!父进程等待两个子进程终止后，输出如下的信息后终止Parent Process is Killed!二、实验目的（1）加深对进程概念的理解，明确进程和程序的区别。
（2）进一步认识并发执行的实质。
（3）分析进程竞争资源现象，学习解决进程互斥的方法。
（4）了解Linux系统中进程通信的基本原理。
三、实验题目编写一段程序，使其现实进程的软中断通信。
要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child Processll is Killed by Parent!Child Processl2 is Killed by Parent!父进程等待两个子进程终止后，输出如下的信息后终止Parent Process is Killed!四、设计思路和流程图五、源程序#include<stdio.h>#include<signal.h>#include<unistd.h>void waiting(),stop(),alarming(); int wait_mark;main(){int p1,p2;if(p1=fork()) /*创建子进程p1*/{if(p2=fork()) /*创建子进程p2*/{wait_mark=1;signal(SIGINT,stop); /*接收到^c信号，转stop*/signal(SIGALRM,alarming);/*接受SIGALRMwaiting();kill(p1,16); /*向p1发软中断信号16*/kill(p2,17); /*向p2发软中断信号17*/wait(0); /*同步*/wait(0);printf("parent process is killed!\n");exit(0);}else{wait_mark=1;signal(17,stop);signal(SIGINT,SIG_IGN); /*忽略^c信号*/while (wait_mark!=0);lockf(1,1,0);printf("child process2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else{wait_mark=1;signal(16,stop);signal(SIGINT,SIG_IGN); /*忽略^c信号*/while (wait_mark!=0)lockf(1,1,0);printf("child process1 is killed by parent!\n");lockf(1,0,0);exit(0);}}void waiting(){sleep(5);if (wait_mark!=0)kill(getpid(),SIGALRM);}void alarming(){wait_mark=0;}void stop(){wait_mark=0;}六、运行结果不做任何操作等待五秒钟父进程回在子进程县推出后退出，并打印退出的顺序；或者点击ctrl+C后程序退出并打印退出的顺序。
实验报告的基本内容及要求
1．实验预习
在实验前每位同学都需要对本次实验进行认真的预习，并写好预习报告，在预习报告中要写出实验目的、要求，需要用到的仪器设备、物品资料以及简要的实验步骤，形成一个操作提纲。
对实验中的安全注意事项及可能出现的现象等做到心中有数，但这些不要求写在预习报告中。
设计性实验要求进入实验室前写出实验方案。
2．实验记录
学生开始实验时，应该将记录本放在近旁，将实验中所做的每一步操作、观察到的现象和所测得的数据及相关条件如实地记录下来。
实验记录中应有指导教师的签名。
3．实验总结
主要内容包括对实验数据、实验中的特殊现象、实验操作的成败、实验的关键点等内容进行整理、解释、分析总结，回答思考题，提出实验结论或提出自己的看法等。
实验报告学院：专业：班级：
注：各学院可根据教学需要对以上栏木进行增减。
表格内容可根据内容扩充。
