第9章进程同步与死锁实验

合集下载

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

操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。

进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。

本实验报告将介绍进程管理的基本概念、原理和实验结果。

一、进程管理的基本概念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 如上图所⽰：如果要解决多个⽣产者和消费者的问题：第⼀步：分析上图得出了两种关系，分别是异步和同步的关系第⼆步：异步关系的是⽣产者和⽣产者之间的，因为同⼀时刻只能有⼀个⽣产者访问缓冲区，所以我们就可以设置临界资源 .获得临界资源的⽣产者才能把产品放到缓冲区⾥第三步：同步关系有两个，⾸先是⽣产者和缓冲区之间，再是缓冲区和消费者之间。

操作系统原理进程管理进程同步互斥与通信、死锁

同步
多个进程因为合作产生的直接制约关系，使得进程有一定的先后执行关系。
互斥
多个进程在同一时刻只有一个进程能进入临界区。
信号量与PV操作
信号量
一个整型变量，可以对其执行P操作和V操作，常用于实现进程同步与互斥。
PV操作
对信号量的操作，P操作表示申请资源，V操作表示释放资源。
实现原理
通过信号量的增减来控制进程的执行顺序，实现同步与互斥。
经典同步问题解析
生产者消费者问题
生产者生产产品放入缓冲区，消费者从缓冲区取出产品消费，需要保证生产者和消费者的同步与互斥。
哲学家进餐问题
五个哲学家围坐在一张圆桌旁，做思考和进餐两件事情，需要保证每个哲学家在拿起左右两只筷子时不会发生死锁。
读者写者问题
允许多个读者同时读文件，但只允许一个写者写文件，需要保证读者和写者之间的同步与互斥。
03
进程通信
进程通信方式
01
共享内存
允许多个进程访问同一块内存空间，进程间通过读写共享内存中的数据进行通信。
消息传递
02
03
管道通信
进程间通过发送和接收消息进行通信，消息可以包含数据、控制信息等。
管道是一种半双工的通信方式，数据只能单向流动，通常用于父子进程间的通信。
消息传递机制
直接通信方式
信。
共享内存
共享内存允许多个进程访问同一块内存空间，进程间通过读写共享内存中的数据进行通信。使用共享内存进行通信时，需要注意同步和互斥问题，以避免数据不一致和竞争条
件等问题。
04
死锁问题
死锁概念及产生原因
死锁概念
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法向前推进。

进程同步及死锁

附件（四）之欧侯瑞魂创作深圳年夜学实验报告课程名称：把持系统实验项目名称：进程（线程）同步及死锁学院：计算机与软件学院专业：计算机科学与技术指导教师：陈说人：学号：班级：实验时间：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);。

OS-03进程管理_进程同步互斥与通信、死锁

加锁机制虽然可以实现进程之间的互斥，但执行效率低、浪费处理机资源。因为任何进程都不能直接进入临界区，必须不停地循环检查 x 的值，等待锁位变为 1, 消耗了有价值的 CPU时间。
加锁机制存在不公平性，导致某些进程一直优先进入临界区，而某些进程可能一直无法进入临界区
引入信号量机制—P/V 操作
信号量机制
信号量（semaphore）：一个与资源有关的，初值为非负数的整型变量称为信号量。用S表示，初值和资源有关
P、V操作：定义在信号量S上的一组操作，由P原语和V原语组成，能对信号量s进行修改
信号量是一种特殊的变量，只能由P，V操作进行访问
信号量机制
P 原语—— P(S) S := S - 1；如果 S > =0，则表示有资源，该进程继续执行；如果 S < 0，则表示已无资源，执行原语的进程被置成阻塞状态，并使其在 S 信号量的队列中等待，直至其他进程在 S 上执行 V 操作释放它为止
互斥：硬件的支持专门的机器指令在硬件级，对存储器单元的访问排斥到相同单元的其他访问。基于这一点，处理器的设计者提出了一些机器指令，用于保证两个动作的原子性，如在一个取指令周期中对一个存储器单元的读和写或者读和测试。由于这些动作在一个指令周期中执行，它们不会受到其他指令的干扰如：test-and-set指令，swap指令等
p53
§3.6 进程同步与同步
进程P1和P2共享同一打印机资源，其操作流程如下： p1: entry code使用打印机exit code p2: entry code使用打印机exit code
系统打印机即为——临界资源 P1和p2的访问临界资源打印机的代码即为——临

《操作系统》课程实验报告

《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。

二、实验环境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）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。

实验2进程同步与死锁

实验步骤
01
1. 设计进程同步实验程序
02 设计两个或多个进程，它们需要访问共享资源。
03 使用信号量或其他同步机制来实现进程间的同步。
实验步骤
2. 编译和运行实验程序
1
2
使用适当的编译器编译实验程序。
3
运行实验程序，并观察程序的输出结果。
实验步骤
01
3. 分析实验结果
02
分析程序的输出结果，验证进程同步机制的正确性。
04 实验内容与步骤
实验目的
01
学习和掌握进程同步的基本概念和方法。
02
理解和掌握死锁的产生原因和解决方法。
通过实验，加深对进程同步和死锁的理解，提高分析和解决问
03
题的能力。
实验环境
操作系统：Windows 10或Linux。开发工具：Visual Studio Code或GCC编译器。编程语言：C或C。
死锁对进程同步的影响
01
系统崩溃
资源浪费
02
03
性能下降
死锁可能导致系统无法正常运行，进而影响进程同步机制的有效性。
死锁发生时，相关进程持有的资源被长时间占用而无法释放，造成资源浪费。
死锁会导致系统性能严重下降，因为相关进程无法继续执行，同步机制也无法发挥作用。
进程同步与死锁的相互作用
死锁的危害
资源浪费
01
死锁发生时，相关进程长时间占用系统资源但又无法继续执行，
导致系统资源浪费。
系统性能下降
02
由于死锁进程长时间占用CPU和其他资源，使得其他进程得不
到及时执行，从而导致系统性能下降。
系统崩溃
03
如果死锁持续发生且得不到及时处理，可能会导致系统崩溃或

操作系统-进程管理与进程同步-实验报告

实验一、进程管理与进程同步一、实验目的了解进程管理的实现方法，理解和掌握处理进程同步问题的方法。

二、实验内容实现银行家算法、进程调度过程的模拟、读者-写者问题的写者优先算法。

实验步骤：理解安全性算法和银行家算法的核心机制：针对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. 内存一致性问题：在分布式系统中，不同节点的内存可能存在一致性问题。

当一个进程修改了自己所在节点的内存，并且其他节点也有相应的副本时，就可能会出现读取到不一致数据的问题。

4进程的同步与通信进程死锁

20
例2： P1,P2两进程使用同一打印机。如果不互斥使用会交叉输出。
P1 Entry code
使用打印机
exit code
P2 Entry code
使用打印机
exit code
21
例3: 对共享变量count的互斥访问。
Parbegin
P1:
{
Entry code
M:=count;
M:=M+1;
进程1的程序 disableInterrupt(); Balance=balance+amount; enableInterrupt();
进程2的程序 disableInterrupt(); Balance=balance-amount; enableInterrupt();
24
2、“Test_and_Set”指令
Parend；
1）并发语句示例 1
Parbegin read（a）； read（b）；
Parend； c= a+b； write（c）；
9
2）并发语句示例2
Var F,G:file of T;
r,s:T;
reset(F);
read(F,r); while not eof(F) do{ s=r; Parbegin write(G,s); read(F,r); Parend; }
界段，通常把这段代码称为进入区(申请，判断)。 2）在退出临界段后，必须有一段代码来清除“正在访
问临界段”标志，或发出本进程已经退出临界段的信息，把这段代码称为退出区（释放）。
19
一个访问临界资源的进程描述如下： While (1) { entry code; //进入区
critical code; //临界段 exit code; //退出区 remainder code;//剩余区 }；

山东大学操作系统实验6死锁问题实验

sem_init(&mutex2,0,1);
sem_init(&mutex3,0,1);
sem_init(&mutex4,0,1);
t=malloc(6*sizeof(pthread_t));
printf("现在开始火车行驶问题模拟\n");
printf("---------------------------------------\n");
Rw:
#include<stdlib.h>
#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
void* read(void* tid);
void* write(void* tid);
//使用经典读写互斥解决这一问题，即当从甲地往乙地有一辆火车时，
（5）火车单行道调度试验是通过将火车单行道两端所有权表示为两种资源，一个城市想要开火车到对方城市需要同时获得单行道两端（两种资源）所有权，类似哲学家就餐问题使用条件变量表示资源是否可用。可以将哲学家问题潜移默化修改哲学家个数成2就是火车单行道问题解决方案。任意时刻只有一个进程获得管程所有权，解决了死锁问题。
举个例子，当有多个进程需要打印文件时，如果系统分配打印机的策略是最短文件优先，那么长文件的打印任务将由于短文件的源源不断到来而被无限期推迟，导致最终的饥饿甚至饿死。
而产生死锁的原因可归结为如下两点：
（1）竞争资源。当系统中供多个进程共享的资源如打印机、公用队列等，其数目不足以满足进程的需要时，会引起诸进程的竞争而产生死锁。
sleep(rate);

操作系统-同步与死锁实验

操作系统实验报告完成人姓名：李国鹏学号：201258503210报告时间：2014.11一、实验内容编写一段程序，使其现实进程的软中断通信。

（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．实验总结
主要内容包括对实验数据、实验中的特殊现象、实验操作的成败、实验的关键点等内容进行整理、解释、分析总结，回答思考题，提出实验结论或提出自己的看法等。

实验报告学院：专业：班级：
注：各学院可根据教学需要对以上栏木进行增减。

表格内容可根据内容扩充。

同步及死锁

一、车船问题解法１：将二个桥作为一个临界资源程序描述main( )车进程i( )船进程j( ){ int mutex=1；i=1,2,3…. j=1,2,3….∕*互斥信号灯*∕｛到B桥｛到A桥P(mutex) P(mutex) cobegin 过B桥吊起A桥车进程i ( ) ; 到A桥吊起B桥∕* i=1,2,3…. 过A桥过二桥船进程j( ) ；V(mutex) 放下B桥∕* j=1,2,3…. } 放下A桥coend V(mutex) } }问题：效率太低解法２：将每个桥作为一个临界资源。

车、船进程对桥的申请次序相同。

由于车多，故按车的顺序。

程序描述:main( ) { int SB=1； ∕* B桥互斥信号灯int SA=1；∕* A 桥互斥信号灯cobegin while (还有车) { 车进程( ) }； while (还有船) { 船进程( ) }； coend } 问题：?解法3：将每个桥作为一个临界资源，将弯道作为N （如:20）个缓冲区。

过船时，车可藏到弯道内车进程( ) ｛到B 桥 P(SB) 过B 桥V(SB) 到A 桥 P(SA) 过A 桥 V(SA) }船进程( ) ｛到A 桥 P(SB) 吊起B 桥 P(SA) 吊起A 桥过二桥放下A 桥 V(SA) 放下B 桥 V(SB)}程序描述:更进一步的考虑：二个桥都吊起来后，后面的船能否接着跟进？二个桥都放下来后，后面的车能否接着跟进（不考虑弯道）？二、过隧道的问题1、最基本的解法：将整个隧道作为一个临界资源2、改进的算法1：每边的第一个进程抢互斥信号灯，后边的进程不受限制地跟进每边的最后一个进程，出隧道时释放互斥信号灯。

注意：程序描述: Array main( ){ mutex=1 /*隧道互斥信号灯SB=1；/*BcountB= 0 /*B边计数SA=1；/*AcountA= 0 /*A边计数cobeginA边进程i( ) ；i=1、2．．B边进程j( ) ；j=1、2．coend }更进一步的考虑：当另一边有人等待时，规定每边能跟进的最多人数当本边较长时间无人，且另一边有人等待时，换边！1、证明(反证法)：设每个进程的最大资源需求数为ri ( i=1，2，．．．p)。