《死锁》实验指导书
操作系统实验3_死锁
实验三死锁一、实验内容模拟实现资源分配。
二、实验目的多个进程动态地共享系统的资源可能会产生死锁现象。
死锁的产生，必须同时满足四个条件，第一个是互斥条件，即一个资源每次只能由一个进程占用；第二个为等待条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其它资源；第三个是非出让条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。
防止死锁的机构只须确保上述四个条件之一不出现，则系统就不会发生死锁。
在实验中假定系统中任一资源在每一时刻只能则由一个进程使用，任何进程不能抢占它进程正在使用的资源，当进程得不到资源时必须等待。
因此只要资源分配策略能保证进程不出现循环等待，则系统就不会发生死锁。
本实验要求学生编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁的发生。
三、实验题目本实验中共有两个实验题。
第一题：用银行家算法实现资源分配。
要求：(1) 设计一个3个并发进程共享10个同类资源的系统，进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。
(2) 设计用银行家算法和随机分配算法，实现资源分配的两个资源分配程序，应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。
(3) 确定一组各进程依次申请资源数的序列，在相同的情况下分别运行上述两种资源分配程序，观察运行结果。
[提示]：(1) 银行家算法，顾名思义是来源于银行的借贷业务，一定数量的本金要应付多个客户的借贷周转，为了防止银行因资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似的问题，系统中有限的资源要供多个进程使用，必须保证得到资源的进程能在有限的时间内归还资源，以供它进程使用资源。
如果资源分配不得当就会发生进程循环等待资源，各进程都无法继续执行下去的死锁现象。
死锁的检测和预防
实验三：死锁的检测和预防一、实验目的1、进一步了解进程的并发执行。
2、加强对进程死锁的理解3、是用银行家算法完成死锁检测二、实验内容给出进程需求矩阵、资源向量以及一个进程的申请序列。
使用进程启动拒绝和资源分配拒绝（银行家算法）模拟该进程组的执行情况。
要求：初始状态没有进程启动计算每次进程申请是否分配？如：计算出预分配后的状态情况（安全状态、不安全状态），如果是安全状态，输出安全序列。
每次进程申请被允许后，输出资源分配矩阵A和可用资源向量V。
每次申请情况应可单步查看，如：输入一个空格，继续下个申请三、实验环境VC++四、实验原理及实验思路1、安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态一定是没有死锁发生。
2、不安全状态:不存在一个安全序列。
不安全状态一定导致死锁。
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
3、银行家算法：把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
4、银行家算法的思路：1.进程一开始向系统提出最大需求量.2.进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.3.若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待.5、银行家算法的数据结构：1.系统剩余资源量A[n],其中A[n]表示第I类资源剩余量.2.各进程最大需求量,B[m][n],其中B[j][i]表示进程j对i类资源最大需求.3.已分配资源量C[m][n],其中C[j][i]表示系统j程已得到的第i资源的数量.4.剩余需求量.D[m][n],其中D[j][i]对第i资源尚需的数目.五、流程图银行家算法：安全检测：六、源代码#include "string.h"#include <stdio.h>#include <stdlib.h>#define M 5#define N 3#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int AVAILABLE[N]={10,5,7};/*M个进程对N类资源最大资源需求量*/int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};/*M个进程还需要N类资源的资源量*/int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*M个进程还需要N类资源的资源量*/int Request[N]={0,0,0};void main(){int i=0,j=0;char flag='Y';char finishFlag='Y';void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();while(finishFlag=='Y'||finishFlag=='y') //可以分配资源{i=-1;while(i<0||i>=M) //判断申请的资源号是否有效{printf("请输入需申请资源的进程号（从0到%d，否则重输入!）:",M-1);scanf("%d",&i);if(i<0||i>=M)printf("输入的进程号不存在，重新输入!\n");}printf("请输入进程%d申请的资源数\n",i);for (j=0;j<N;j++){printf("资源%d:",j);scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]) //进程申请资源数大于进程还需要的资源{printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量!申请不合理，出错!请重新选择!\n",i,i,j);flag='N';break;}else{if(Request[j]>AVAILABLE[j]) //进程申请资源数大于系统可用该类资源量{printf("进程%d申请的资源数大于系统可用%d类资源的资源量!申请不合理，出错!请重新选择!\n",i,j);flag='N';break;}}}if(flag=='Y'||flag=='y'){int result;changdata(i);result=chkerr(i);if(result==1){rstordata(i);showdata();}elseshowdata();}//else//showdata();printf("\n");printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ");getchar();scanf("%c",&finishFlag);}}void showdata() //显示各类资源的分配情况{int i,j;printf("系统可用的资源数为:\n");printf(" ");for (j=0;j<N;j++){printf(" 资源%d:%d ",j,AVAILABLE[j]);}printf("\n");printf("各进程还需要的资源量:\n");for (i=0;i<M;i++){printf(" 进程%d ",i);for (j=0;j<N;j++){printf("资源%d:%d ",j,NEED[i][j]);}printf("\n");}printf("各进程已经得到的资源量: \n");for (i=0;i<M;i++){printf(" 进程%d ",i);for (j=0;j<N;j++)printf("资源%d:%d ",j,ALLOCATION[i][j]);printf("\n");}}void changdata(int k){int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}void rstordata(int k){int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chkerr(int s) //检查是否能够分配该资源{int WORK,FINISH[M],temp[M];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){WORK=AVAILABLE[j];i=s;while(i<M){if (FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;temp[k]=i;k++;i=0;}else{i++;}}for(i=0;i<M;i++)if(FINISH[i]==FALSE){printf("\n系统不安全!!! 本次资源申请不成功!!!\n\n");return 1;}}printf("\n经安全性检查，系统安全，本次分配成功。
操作系统实验任务书(5)-死锁
沈阳工程学院
学生实验任务书
实验室名称：计算机实验室实验课程名称：操作系统
实验项目名称：死锁
一．实验目的
1．加深了解有关资源申请、避免死锁等概念。
2．体会和了解死锁和避免死锁的具体实施方法。
二．实验设备
PC机一台，C软件。
三．实验项目
1．设计进程对各类资源最大申请表示及初值的确定。
2．设定系统提供资源的初始状况。
3．设定每次某个进程对各类资源的申请表示。
4．编制程序，依据银行家算法，决定其资源申请是否得到满足。
5．显示资源申请和分配时的变化情况。
·1·。
操作系统死锁实验报告
程序结构如下：
当进程pi提出资源申请时，系统执行1）若Request[i]≤Need[i],转2）；否则错误返回。2）若Request[i]≤Available,转3）；否则进程等待。3）假设系统分配了资源，则有：
printf("%d",Need[i][j]); printf("\n");}share();}
分配成功分配失败
6．实验分析与体会
通过这次作业不仅使我对操作系统中银行家算法有了进一步的掌握，银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。
与预防死锁的几种方法相比较，限制条件少，资源利用程度提高了。
由于要寻找一个安全序列，实际上增加了系统的开销。Banker algorithm最重要的一点是：保证操作系统的安全状态！这也是操作系统判断是否分配给一个进程资源的标准！
实验日期：2010年6月8日
教师评语
签名：年月日
2）若Finish[i]=False&&Need<=Work,则执行3）;否则执行4）
3）进程P获得第i类资源,则顺利执行直至完成!并释放资源:
Work=Work+Allocation; Finish[i]=true;转2)
4） 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!
操作系统实验报告七
操作系统实验报告七一、实验目的1、死锁如何发生，如何在我们的内核中引发死锁。
2、针对情况解决我们程序的死锁，以及了解更科学的死锁解决方式。
二、实验过程（一）死锁的出现首先编辑src/main.rs，在not_main()函数的空循环中调用print!宏：1、loop{}中print!宏与handle_uart0_rx_irq()中print!宏竞争检查src/interrupts.rs中的handle_uart0_rx_irq()函数，可以看到我们之前写了一个输入中断回调函数，在函数中调用了print!宏输出信息。
直接编译并运行，预期在输入时触发死锁。
不停地乱序敲击键盘，此时有概率出现卡死，按键无法再次输入内容，即触发死锁现象。
2、loop{}中print!宏与handle_timer_irq()中print!宏竞争检查src/interrupts.rs中的handle_timer_irq()函数，可以看到我们之前写了一个时间中断回调函数，在函数中调用了print!宏打点。
但它之前被我们注释掉了，因此我们取消注释：然后我们编译并运行，预期在打第一个点时会触发死锁。
（二）死锁的简单处理为了防止出现死锁，一个简单的办法是在使用锁时禁止中断。
但需要注意的是禁用中断会增加中断响应延迟，而中断响应延迟一个非常重要的性能指标。
所以只能在短时间内禁用中断。
1、编辑src/uart_console/mod.rs，引入asm!宏。
2、编辑src/uart_console/mod.rs中的_print()函数，在处理输入时先关闭中断，再打开。
三、测试及分析两种情况下，死锁均已消失四、心得体会在单进程系统中，死锁更多的发生于进程对某一资源的竞争现象。
例如我们在实验中中断等输出函数对uart硬件资源争夺。
而多进程中的死锁更多的发生于两个不同进程发生了相互调用或资源竞争，互相等待对方结束进程的情况。
这时候我们称系统产生了死锁或系统处于死锁状态。
死锁实验报告
操作系统实验二报告一．实验名称：死锁的检测与解除二．实验目的：观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生。
三．实验内容：死锁的检测算法：1．找出不再申请资源的进程，将它们所占的资源与系统中还剩余的资源加在一起作为“可分配的资源”，同时对这些进程置标志；2．检测所有无标志的进程，找出一个所需资源量不超过“可分配的资源”量的进程，将其所占用的资源添加到“可分配的资源”中，同时为该进程置标志；重复2）直到所有进程均有标志或无标志的进程的所需资源量均超过“可分配的资源”量；3．若进程均有标志，说明系统当前不存在死锁；若存在无标志的进程，则表示系统当前已有死锁形成，这些无标志的进程就是一组处于死锁状态的进程。
死锁的解除：当死锁检测程序检测到有死锁存在时，一般采用两种方式来解除死锁：1．终止进程：终止一个或多个涉及死锁的进程的执行，收回它们所占的资源再分配。
2．抢夺资源：从涉及死锁的一个或几个进程中抢夺资源，把夺来的资源再分配给卷入死锁的其他进程，直到死锁解除。
四．实验代码：#include <iostream>using namespace std;#define mp 50 //最大进程数#define mr 100 /最大资源数int keyong[mr]; //可用资源数组int MAX[mp][mr]; //最大需求矩阵int fenpei[mp][mr]; //分配矩阵int need[mp][mr]; //剩余需求矩阵bool FINISH[mp]; //系统是否有足够资源分配int p[mp]; //记录序列int Work[mr]; //工作数组int m,n; //m个进程,n个资源int l=0;void Init(); //初始化bool Safe();void jc();void main(){ Init();Safe();if(l!=m)jc();}void Init() //初始化算法{ int i,j;cout<<"请输入进程的数目:";cin>>m;cout<<"请输入资源的种类:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++){ for(j=0;j<n;j++){cin>>fenpei[i][j];need[i][j]=MAX[i][j]-fenpei[i][j];if(need[i][j]<0){ cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl; j--;continue; }}}cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){ cin>>keyong[i]; }cout<<"剩余需求矩阵:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){ cout<<need[i][j]<<" ";if(j==n-1)cout<<endl;}cout<<"各资源现有数量:"<<endl;for(i=0;i<n;i++)cout<<keyong[i]<<" ";cout<<endl;}bool Safe() /*安全性算法*/{ int i,j,k;for(i=0;i<n;i++)Work[i]=keyong[i];for(i=0;i<m;i++){ FINISH[i]=false; //判断进程i是否已执行}for(i=0;i<m;i++){if(FINISH[i]==true){ continue;}else{ for(j=0;j<n;j++){ if(need[i][j]>Work[j]){ break;}}if(j==n){ FINISH[i]=true;for(k=0;k<n;k++){ Work[k]+=fenpei[i][k]; //进程i执行完后回收资源}p[l++]=i;i=-1;}else{continue;}}if(l==m){cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){cout<<p[i];if(i!=l-1){cout<<"-->";}}cout<<""<<endl;return true;}}cout<<"会发生死锁,发生死锁的进程是:"<<endl;for(i=0;i<m;i++)if(FINISH[i]==false)cout<<i<<" ";cout<<endl;return false;}void jc(){int i,j,k,q;i=0;while(i<m&&FINISH[i]==false) //寻找没执行的{for(j=0;j<n;j++){keyong[j]+=fenpei[i][j]; //回收fenpei[i][j]=0;}if(Safe())cout<<"死锁已解除"<<endl;elsei++;Safe();}}五．实验结果进程已拥有资源数总需求资源数1 （0.0.1.2）（0.0.1.2.）2 （2.0.0.0）（2.7.5.0）3 （0.0.3.4）（6.6.5.6）4 （2.3.5.4）（4.3.5.6）5 （0.3.3.2）（0.6.5.2）其中系统可用资源数为2 1 0 0给进程3 分配资源数0 1 0 0六．实验心得：加深理解了有关资源申请分配、检测以及避免死锁等概念，了解死锁和避免死锁的具体实施方法。
操作系统死锁实验
printf("E %d enter A\n",serialNum);
sleep(2);
pthread_mutex_unlock(&s3);
pthread_mutex_lock(&s4);
printf("E %d enter D\n",serialNum);
pthread_mutex_t s1;//线程互斥信号量，对应C路段
pthread_mutex_t s2; //线程互斥信号量，对应B路段
pthread_mutex_t s3; //线程互斥信号量，对应A路段
pthread_mutex_t s4; //线程互斥信号量，对应D路段
int i;
void *s(void *a1) //南边来的汽车的线程执行体
{
int serialNum=*((int*)a1);//取当前汽车序号
pthread_mutex_lock(&s1);
printf("S %d enter C\n",serialNum);
sleep(2);
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#define Max 7
pthread_t E[Max];//从东方来的汽车。每辆汽车对应一个线程。
pthread_t W[Max];//从西方来的汽车
pthread_t S[Max];//从南方来的汽车
}
int main(int argc,char *argv[])
死锁的检测与解除(操作系统实验报告)
1.输入系统进程数量n和资源类型数量m。
2.输入每类资源的数量。
3.输入每个进程每类资源的最大需求量和已获资源量。
4.检验系统的安全系。
5.若检测结果为系统不安全，可以对死锁进行解除，直到安全为止，再检测。
6．重复5操作，直到所有进程运行完毕。
四、实验结果与结论：（经调试正确的源程序和程序的运行结果）
composite4.setData("name","composite4");
formToolkit.adapt(composite4);
formToolkit.paintBordersFor(composite4);
/*--------------------------------标签---------------------------------------*/
formToolkit.adapt(composite3);
formToolkit.paintBordersFor(composite3);
composite3.setLayout(stackLayout2);
composite4=newComposite(composite3, SWT.BORDER);
label_5.setBounds(0, 55, 112, 26);
label_5.setData("name","label_5");
formToolkit.adapt(label_5,true,true);
label_5.setText("最大资源需求量");
label_6=newLabel(composite4, SWT.NONE);
实验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
如果死锁持续发生且得不到及时处理，可能会导致系统崩溃或
《死锁避免》实验报告
一、实验目的本次实验旨在通过模拟操作系统的资源分配和请求过程，深入理解死锁的概念、产生死锁的必要条件以及如何通过银行家算法来避免死锁的发生。
通过实验，学生能够掌握以下知识点：1. 死锁的概念及产生条件；2. 银行家算法的基本原理和实现方法；3. 资源分配和请求过程中的安全性检查；4. 通过银行家算法避免死锁的发生。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 20194. 实验环境：一台配置较高的计算机三、实验原理1. 死锁的概念死锁是指多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，这些进程都将无法继续执行。
2. 产生死锁的必要条件产生死锁的必要条件有四个，分别为：（1）互斥条件：资源不能被多个进程同时使用；（2）持有和等待条件：进程已获得至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时该进程会等待；（3）非抢占条件：已分配给进程的资源，在进程完成之前，不能被抢占；（4）循环等待条件：存在一种进程资源的循环等待链，即进程P1等待P2占有的资源，P2等待P3占有的资源，以此类推，最后Pn等待P1占有的资源。
3. 银行家算法银行家算法是一种避免死锁的算法，通过以下步骤实现：（1）初始化系统资源、进程最大需求、已分配资源等数据结构；（2）当进程请求资源时，判断是否满足以下条件：a. 当前可用资源数量大于等于进程请求的资源数量；b. 根据当前资源分配情况，系统处于安全状态；若满足以上条件，则分配资源；否则，进程等待。
（3）当进程释放资源时，更新可用资源数量和分配资源情况。
四、实验内容1. 设计系统资源、进程最大需求、已分配资源等数据结构；2. 实现银行家算法，包括资源分配、安全性检查等功能；3. 模拟进程请求资源和释放资源的过程，观察系统状态变化；4. 分析实验结果，验证银行家算法是否能够避免死锁的发生。
死锁的检测与解除
死锁的检测与解除--操作系统实验报告题目：死锁的检测与解除指导老师：班级：姓名：学号：时间：实验二 死锁的检测与解除一、实验目的系统为进程分配资源时并不一定能满足进程的需求，因此检测系统的安全性是非常有必要的。
安全性的检测在之前的实验中用银行家算法得以实现，此次实验增加了另一个问题：即当系统死锁时如何解除死锁。
通过此次实验，可以深刻的体会死锁的检测与解除的方法。
二、实验内容编程实现死锁的检测与解除，并上机验证。
实验环境：Microsoft Visual Studio 2010三、算法描述程序中的数据结构：1) 可用资源向量Available : 这是一个含有m 个元素的数组，其中的每一个元素代表一类可利用资源数目。
2) 最大需求矩阵Max : 它是一个n m ⨯的矩阵，定义了系统中n 个进程中得每一个进程对m 类资源的最大需求。
3) 可分配矩阵Allocation : 这也一个n m ⨯的矩阵，定义了系统中每一类资源当前已分配给每一进程的资源数。
4) 需求矩阵Need : 这表示每一个进程尚需的各类资源数。
5) 综上所述：[][][][][][]Need i j Max i j Allocation i j =-。
该程序是在银行家算法的基础上添加了死锁的解除模块得来的，死锁的解除采用的方法是：找到已分配资源最大的死锁进程，剥夺其已分配资源，再次检测是否发生死锁。
1) 设i request 是进程i P 的请求向量，如果[]i request j K =，表示进程i P 需要K 个j R 类型起源。
当i P 发出资源请求后，进行检查，如果合格，修改Available 、Allocation 、Need 的值。
2) 用安全性算法检查是否存在安全序列，如果存在，输出安全序列；如果不存在，即为死锁，进行解锁操作。
3) 统计[,]Allocation i j 的值，找出占用资源最多的进程i P ，将其撤销，回收占用的资源，修改一下的数据结构中的值：[]:[]+[,]Available j Available j Allocation i j =；[,]:0Allocation i j =；用安全性算法进行检查，如果仍有死锁，重复步骤3，知道解锁为止。
实验报告死锁
一、实验目的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）实现死锁避免算法采用银行家算法，判断当前分配情况是否满足安全序列。
山东大学操作系统实验6死锁问题实验
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);
死锁检测
实验四死锁检测实验（一）实验目的采用银行家算法来预防死锁是可靠的，但也是非常保守的，因为它限制了进程对资源的存取，从而降低了进程的并发运行程度。
死锁检测并不限制进程对资源的申请，只要有，就分配，但这也可能造成死锁。
但由于死锁并不是经常发生的，故大大提高了系统运行的效率。
通过本实验，可使学生进一步加深理解和掌握死锁的检测算法。
（二）实验题目两个题目任选其一：1、编写对每种类型多个资源的死锁检测算法。
2、使用检测“进程—资源循环等待链”的方法，编写死锁检测算法（有参考代码）（三）实验要求题目1：（1）死锁检测算法的数据结构参考教材3.4.2节图3-6的现有资源矩阵E、可用资源矩阵A、当前分配矩阵C、进程请求资源矩阵R。
（2）完成对教材中图3-7的死锁检测算法例子的测试。
（3）完成在图3-7基础上，修改进程2的请求分别为2 1 0 1 下的死锁检测。
题目2：（1）利用“进程—资源循环等待链”的方法，编写死锁检测算法的具体方法可参考教材3.4.1节的算法，在了解此算法思想的基础上，也可参考给定代码；具体代码描述见附件1。
（2）利用教材图3-5 a）中的资源分配图完成对该算法的测试。
（四）实验报告要求•画出所实现算法的详细框图；•说明所采用的数据结构；•列出输入数据（进程和所申请的资源数据可用命令行或文件输入）；•列出运算的输出结果（输入结果包括是否死锁，死锁进程有哪些，也可包含中间结果）；•实验总结与心得。
•根据情况可以列出代码。
附件1：模拟死锁检测算法描述1．输入：“资源分配表”文件，每一行包含资源编号、进程编号两项（均用整数表示，并用空格分隔开），记录资源分配给了哪个进程。
“进程等待表”文件，每一行包含进程编号、资源编号两项（均用整数表示，并用空格分隔开），记录进程正在等待哪个资源。
下面是一个示例：资源分配表：1 12 23 3进程等待表：1 22 33 12．处理要求：程序运行时，首先提示“请输入资源分配表文件的文件名：”；再提示“请输入进程等待表文件的文件名：”。
实验四,死锁
实验四死锁一、实验目的1、了解死锁与饥饿产生的条件2、了解死锁的解决办法3、掌握利用银行家算法进行死锁避免二、相关知识1、进程并发执行的概念2、资源分配拒绝（银行家算法）（1）银行家算法中的数据结构假定系统中有n个进程(P1,P2,…,Pn)，m类资源(R1,R2,…Rm)，银行家算法中所使用的数据结构如下：可利用资源向量Available。
它是一个含有m个元素的数组，其中每个元素代表一类可利用资源的数目。
若Available(j)=k，表示系统中现有空闲的Rj类资源k个。
最大需求矩阵Max。
n*m矩阵，表示n个进程的每一个对m类资源的最大需求。
如果Max[i,j]=k，表示进程Pi需要Rj类资源的最大数量为k。
分配矩阵Allocation。
n*m矩阵，表示每个进程分配的资源数。
如果Allocation[i,j]=k，表示进程Pi当前已分配到的Rj类资源的数目为k。
需求矩阵Need。
n*m矩阵，表示每个进程还需要各类资源数。
如果Need[i,j]=k 表示进程Pi还需要Rj类资源k个。
Need[i,j]=Max[i,j]-Allocation[i,j]。
设Requesti是进程Pi的请求向量，Requesti[j]=k表示进程Pi 请求分配Rj类资源k个。
进程Pi提出资源申请时，系统执行下列步骤：(1) 若Requesti[j] ≤Need[i, j]，转(2)；否则错误返回，因为进程所需要的资源数目已超过它宣布的最大值。
(2) 若Requesti[j] ≤Available[j]，转(3)；否则表示系统中尚无足够的资源满足进程Pi的申请，进程Pi必须等待。
(3) 假设系统分配了资源，则有：Available[j]:=Available[j]- Requesti[j];Allocation[i,j]:= Allocation[i,j] + Requesti[j];Need[i,j] := Need[i,j] – Requesti[j](4) 执行安全性算法，若系统新状态是安全的，则分配完成；若系统新状态是不安全的，则恢复原状态，进程等待。
死锁-银行家算法实验报告
死锁-银行家算法实验报告案场各岗位服务流程销售大厅服务岗：1、销售大厅服务岗岗位职责：1)为来访客户提供全程的休息区域及饮品;2)保持销售区域台面整洁;3)及时补足销售大厅物资,如糖果或杂志等;4)收集客户意见、建议及现场问题点；2、销售大厅服务岗工作及服务流程阶段工作及服务流程班前阶段1）自检仪容仪表以饱满的精神面貌进入工作区域2）检查使用工具及销售大厅物资情况，异常情况及时登记并报告上级。
班中工作程序服务流程行为规范迎接指引递阅资料上饮品（糕点）添加茶水工作要求1）眼神关注客人，当客人距3米距离时，应主动跨出自己的位置迎宾，然后侯客迎询问客户送客户注意事项15度鞠躬微笑问候：“您好！欢迎光临！”2）在客人前方1-2米距离领位，指引请客人向休息区，在客人入座后问客人对座位是否满意：“您好！请问坐这儿可以吗？”得到同意后为客人拉椅入座“好的，请入座！”3）若客人无置业顾问陪同，可询问：请问您有专属的置业顾问吗？，为客人取阅项目资料，并礼貌的告知请客人稍等，置业顾问会很快过来介绍，同时请置业顾问关注该客人；4）问候的起始语应为“先生-小姐-女士早上好，这里是XX销售中心，这边请”5）问候时间段为8:30-11:30 早上好11:30-14:30 中午好 14:30-18:00下午好6）关注客人物品，如物品较多，则主动询问是否需要帮助（如拾到物品须两名人员在场方能打开，提示客人注意贵重物品）；7）在满座位的情况下，须先向客人致歉，在请其到沙盘区进行观摩稍作等待；阶段工作及服务流程班中工作程序工作要求注意事项饮料（糕点服务）1）在所有饮料（糕点）服务中必须使用托盘；2）所有饮料服务均已“对不起，打扰一下，请问您需要什么饮品”为起始；3）服务方向：从客人的右面服务；4）当客人的饮料杯中只剩三分之一时，必须询问客人是否需要再添一杯，在二次服务中特别注意瓶口绝对不可以与客人使用的杯子接触；5）在客人再次需要饮料时必须更换杯子；下班程序1）检查使用的工具及销售案场物资情况，异常情况及时记录并报告上级领导；2）填写物资领用申请表并整理客户意见；3）参加班后总结会；4）积极配合销售人员的接待工作，如果下班时间已经到，必须待客人离开后下班；1.3.3.3吧台服务岗1.3.3.3.1吧台服务岗岗位职责1）为来访的客人提供全程的休息及饮品服务；2）保持吧台区域的整洁；3)饮品使用的器皿必须消毒；4）及时补充吧台物资；5）收集客户意见、建议及问题点；1.3.3.3.2吧台服务岗工作及流程阶段工作及服务流程班前阶段1）自检仪容仪表以饱满的精神面貌进入工作区域2）检查使用工具及销售大厅物资情况，异常情况及时登记并报告上级。
死锁的检测与解除终结版
一、实验名称：死锁的检测与解除二、实验内容：设计一个 n个并发进程共享m个系统资源的系统。
进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源。
要求用死锁检测算法检测当某一进程提出资源分配请求时，系统会不会陷入死锁状态；如若陷入死锁状态要求用某种算法解除死锁三、实验目的：当系统为进程分配资源时，若未采取任何限制性措施，则系统必须提供检测和解除死锁的手段，为此，系统必须做到：（1）保存有关资源的请求和分配信息；（2）提供一种算法，以利用这些信息来检测系统是否已进入死锁状态。
某一状态为死锁状态的充分条件是：当且仅当某一状态的资源分配图是不可完全简化的。
通过该实验，可以充分理解死锁的检测与解除的基本原理。
四、实验过程：a)基本思想先对各进程提出的请求资源数进行检查，即检查请求的资源数是否大于可用资源数。
若满足请求，则各进程完成执行。
若陷入死锁状态，则利用撤销进程的方法来解除死锁。
在本实验中，撤销占资源数最多的死锁进程。
b)主要数据结构（1）可利用资源向量Available，它表示了m类资源中每一类资源的可用数目。
（2）把不占用资源的进程（向量Allocation i:=0）记入P[L]序列中。
（3）从进程集合中找到一个Request i<=Work的进程，作如下处理：①将其资源分配图简化，释放出资源，增加工作向量Work:=Work+Allocation i。
②将它记入P[L]中。
（4）若不能把所有的进程都记入P[L]中，便表明系统状态S的资源分配图示不可完全简化的。
因此，该系统状态将发生死锁。
（5）将发生死锁的进程占有的各资源总数记入sum[i]中，得到使sum最大的i值，撤销进程i，若仍发生死锁，则继续撤销下一个进程，直到死锁解除。
若撤销至仅剩一个进程时，还未能解除死锁，则该死锁状态不能解除。
c)流程图★check()函数★jiesuo()函数截屏不产生死锁的情况发生死锁，无法解除的情况发生死锁，并成功解除的情况源程序：#include <iostream>#include <stdio.h>#include <stdlib.h>#include <string.h>using namespace std;//定义全局变量const int x=50,y=50; //x为进程个数y为资源种类数int Available[y]; //各资源可利用的数量int Allocation[x][y]; //各进程当前已分配的资源数量int Request[x][y]; //申请多少资源int Work[y]; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量int Finish[x]; //表示系统是否有足够的资源分配给进程，1为是int p[x]; //存储安全序列int sum[x];//存储各进程占有的总资源数int i,j; //i表示进程，j表示资源int n,m; //n为进程i的数量,m为资源j种类数int l=0; //l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的int c=0; //记数器,记录可执行的进程数//函数声明void chushihua(); //初始化函数bool check(); //检查是否产生死锁算法void show(); //函数show,输出当前状态void jiesuo(); //解除死锁算法void jieshu(); //结束函数void judge();void chushihua(){cout<<"输入进程的数量: ";//从此开始输入有关数据cin>>n;cout<<"输入资源种类数: ";cin>>m;cout<<endl<<"输入各种资源当前可用的数量( "<<m<<" 种): "<<endl;for (j=0; j<m; j++)//m为资源数{cout<<"输入资源"<<j<<" 可利用的数量Available["<<j<<"]: ";cin>>Available[j]; //输入数字的过程Work[j]=Available[j]; //初始化Work[j]，它的初始值就是当前可用的资源数}cout<<endl<<"输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl;for (i=0; i<n; i++) //n为进程数{for (j=0; j<m; j++)//m为资源数{cout<<" 输入进程"<<i<<" 当前已分配的资源"<<j<<" 数量: ";cin>>Allocation[i][j];}cout<<endl;Finish[i]=0;//初始化Finish[i]}cout<<endl<<"输入各进程对各类资源的请求Request["<<n<<"]["<<m<<"]: "<<endl;for (i=0; i<n; i++)//n为进程数{for (j=0; j<m; j++)//m为资源数{cout<<" 输入进程"<<i<<" 对资源"<<j<<" 的请求数: ";cin>>Request[i][j];}cout<<endl;}cout<<endl<<"初始化完成"<<endl;}//显示当前状态函数void show() //函数show,输出当前资源分配情况{int i,j; //局部变量，i表示进程，j表示资源int All[y]; //各种资源的总数量int L1; //局部变量L1cout<<"当前的状态为："<<endl;cout<<"各种资源的总数量:"<<endl;for (j=0;j<m;j++)//m为资源数{cout<<" 资源"<<j<<": ";All[j]=Available[j]; //总数量=可用的+已分配的for(i=0;i<n;i++) //n为进程数All[j]+=Allocation[i][j];cout<<All[j]<<" ";}cout<<endl<<"当前各种资源可用的量为(available):"<<endl;for(j=0;j<m;j++)//m为资源数cout<<" 资源"<<j<<": "<<Available[j]<<" ";cout<<endl<<"各进程已经得到的资源量(allocation): "<<endl;for(i=0;i<m;i++)//m为资源数{cout<<" 资源"<<i<<" ";}cout<<endl;for(L1=0;L1<n;L1++)//n为进程数{cout<<"进程"<<L1<<": ";for (j=0;j<m;j++)cout<<Allocation[L1][j]<<" ";cout<<endl;}cout<<endl<<"各进程对各类资源的请求量(Request):"<<endl;for(i=0;i<m;i++)//m为资源数{cout<<" 资源"<<i<<" ";}cout<<endl;for(L1=0;L1<n;L1++){cout<<"进程"<<L1<<": ";for (j=0;j<m;j++)cout<<Request[L1][j]<<" ";cout<<endl;}}//结束函数void jieshu(){cout<<endl<<endl;cout<<"\t\t 演示计算完毕"<<endl;cout<<endl<<endl;}//死锁检测bool check() //若无死锁则返回true{for(i=0;i<n;i++) //对任一进程进行判断n为进程数{int flag3=0;if(Finish[i]==0) //该进程还未执行完{for(j=0;j<m;j++) //m为资源数{if(Request[i][j]<=Work[j])//请求的资源数<可用资源数flag3=1;else{flag3=0;break;}}if(flag3==1){for(j=0;j<m;j++){Work[j]+=Allocation[i][j];Allocation[i][j]=0;}Finish[i]=1;p[l]=i;l++;i=-1;}}}if(l==n) //若所有的进程都放完,则返回ture,否则返回false{return true;//不存在死锁}else{return false;//存在死锁}}void jiesuo(){int temp,flag1=0;int b=n;//b用于控制已撤销的进程数for(i=0;i<n;i++) //统计死锁资源、释放{int total=0;if(Finish[i]==0) //i进程还未释放完资源{for(j=0;j<m;j++)//m为资源数{total=total+Allocation[i][j];//i进程总共占的资源数sum[i]=total;}}}temp=sum[0];//temp为最大资源数for(i=1;i<n;i++) //找出占资源数最多的死锁进程i{if(temp<sum[i]){temp=sum[i];flag1=i;}}cout<<"撤消占资源最多的进程:"<<flag1<<endl;for(j=0;j<m;j++) //回收资源{Work[j]+=Allocation[flag1][j];Allocation[flag1][j]=0;}Finish[flag1]=1; //完成flag1进程的操作l++;b--;if(check()){cout<<endl;cout<<"成功解除死锁"<<endl;}else{while(b>1){jiesuo(); //如果还没解除,继续放资源}if(b==1)cout<<"无法解除死锁！";}}void judge(){if(check())cout<<"不会发生死锁!"<<endl;else{cout<<"会发生死锁!死锁进程如下："<<endl;for( i=0;i<n;i++) //找出死锁进程{if(Finish[i]==0)cout<<i<<" ";}cout<<endl;jiesuo(); //解锁}}void main() //主函数{cout<<endl;cout<<" *******************死锁的检测与解除示例******************* "<<endl;cout<<endl;cout<<endl;chushihua(); //初始化函数show(); //函数show,输出当前状态judge();check();jieshu();}五、实验小结死锁的检测与解除和银行家算法的数据结构基本相同，至于实验中所实施的死锁解除算法也只是简单撤销某一引起死锁进程所占有资源的简单释放，该实验只是简单模拟了死锁的检测与解除；最大的收获是对死锁定理的理解和对死锁解除算法的认识与实现机理实记。
os课程设计死锁
os课程设计死锁一、教学目标本课程的教学目标是使学生掌握操作系统中死锁的概念、原因、类型及避免方法。
通过本课程的学习，学生应能够：1.理解死锁的定义及其在操作系统中的重要性。
2.识别导致死锁的四个必要条件。
3.区分死锁与饥饿、活锁的区别。
4.分析具体实例中的死锁问题，并提出解决方案。
5.应用死锁理论知识，解决实际操作系统问题。
二、教学内容本课程的教学内容主要包括：1.死锁的定义与基本概念：介绍死锁的定义、特点及在操作系统中的含义。
2.死锁的四个必要条件：分析并理解导致死锁的四个必要条件，即互斥条件、占有和等待条件、不剥夺条件、循环等待条件。
3.死锁的类型与避免方法：介绍死锁的不同类型，如资源分配图、资源分配矩阵等，并学习死锁避免算法，如银行家算法、资源请求算法等。
4.死锁的实际案例分析：分析实际操作系统中的死锁案例，如Linux、Windows等操作系统中的死锁问题，探讨解决方案。
三、教学方法为了提高教学效果，本课程将采用多种教学方法相结合的方式，包括：1.讲授法：通过讲解死锁的基本概念、原因及避免方法，使学生掌握理论知识。
2.案例分析法：分析实际操作系统中的死锁案例，使学生能够将理论知识应用于实际问题。
3.实验法：安排实验课程，让学生动手实践，加深对死锁理论知识的理解。
4.讨论法：学生进行分组讨论，分享学习心得，互相答疑解惑。
四、教学资源为了支持本课程的教学，我们将提供以下教学资源：1.教材：《操作系统原理与实践》等教材，为学生提供理论知识的系统学习。
2.参考书：推荐《现代操作系统》、《操作系统设计与实现》等参考书，丰富学生的知识体系。
3.多媒体资料：提供教学PPT、视频讲座等多媒体资料，帮助学生更好地理解课程内容。
4.实验设备：提供计算机实验室，让学生进行实际操作，增强实践能力。
五、教学评估本课程的评估方式包括以下几个方面：1.平时表现：通过课堂参与、提问、讨论等环节，评估学生的课堂表现，占总评的30%。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《死锁》实验指导书
----哲学家就餐问题
【实验目的】
1.理解死锁的概念和原理；
2.继续加深理解WINDOWS下进程/线程的互斥和同步的实现机制；
【实验要求】
1.在WINDOWS系统中实现哲学家就餐问题的死锁和不死锁两种解法。
【实验内容】
1.编写一个WIN32 MFC应用程序，模拟实现哲学家就餐问题的死锁和不死
锁两种解法。
【实验背景】
1.哲学家就餐问题的描述
有五个哲学家围坐在一圆桌旁，桌中央有一盘通心粉，每人面前有一只空盘子，每两人之间放一只筷子。
每个哲学家的行为是思考，感到饥饿，然后吃通心粉。
为了吃通心粉，每个哲学家必须拿到两只筷子，并且每个人只能直接从自己的左边或右边去取筷子。
2.WINDOWS下进程的同步和互斥有关函数
2.1互斥对象(Mutex)
就是互斥信号量，在一个时刻只能被一个线程使用。
相关API包括：CreateMutex、OpenMutex和ReleaseMutex。
CreateMutex创建互斥对象，返回对象句柄；OpenMutex 打开并返回一个已存在的互斥对象句柄，用于
后续访问；ReleaseMutex释放对互斥对象的占用，使之成为可用。
2.2信号量对象（Semaphore）
就是资源信号量，初始值的取值范围在0到指定最大值之间，用于限制并发访问的线程数。
相关API包括：CreateSemaphore、OpenSemaphore和ReleaseSemaphore。
CreateSemaphore 创建一个信号量对象，在输入参数中指定初值和最大值，返回对象句柄。
OpenSemaphore 打开并返回一个已存在的信号量对象句柄，用于后续访问。
ReleaseSemaphore释放对信号量对象的占用，使之成为可用。
2.3事件对象（Event）
用于通知一个或多个线程某事件的出现。
相关API包括：CreateEvent、OpenEvent、SetEvent、ResetEvent和PulseEvent。
2.4等待操作
WaitForSingleObjec和WaitForMultipleObjects
3．哲学家就餐的不会导致死锁的解法
仅当一个哲学家左右两边的筷子都可用时，才允许他拿筷子。
这样要么一次占有两只筷子（所有线程需要的资源）进行下一步的吃通心粉，然后释放所有的资源；要么不占用资源，这样就不可能产生死锁了。
4．哲学家就餐的可能导致死锁的解法
当筷子（资源）可用时，先分配左边的筷子，等待一会后再分配右边的筷子，由于这个过程中，左边的筷子一直没有释放，就有可能产生死锁。
【实验内容】
1．尝试自行使用VC++6.0创建一个WIN32 MFC应用程序，使用WINDOWS进程/线程相关函数实现哲学家就餐问题的死锁解法和不死锁解法。
要求程序开始运行的时候能够让用户选择“按不产生死锁的方式运行”或“按产生死锁的方式运行”。
选择前者的话，程序按【实验背景】第4小节介绍的方式实现相应的P－V操作；选择后者的话，程序按【实验背景】第3小节介绍的方式实现相应的P－V操作。
2．研究参考代码的实现，写出其实现思路和流程。
参考程序运行过程中会弹出一个消息框提示操作者操作：
1．第一个对话框用于选择运行模式
a．选择yes 表示采用的是运行的防止死锁的方式，这样的话整个程序可以一直运行下去，不会产生死锁。
b．选择no 表示运行产生死锁的方式，此后系统还会接着弹出第二个对话框。
2．第二个对话框用于选择运行时，线程运行的时间
a. 选择 yes 线程时间比较短，很快就可以死锁
b．选择no 线程时间跟选择yes 时候的时间差不多，产生死锁的时间稍微长一点。
【参考资料】
1、MSDN
【预习要求】
1、一定要上机之前熟悉VC的开发。
2、一定要在MSDN查询相关的函数（包括实验二的函数，这次实验的核心部分的函数同实验二！）
3、熟悉就餐者的P－V算法，也就其伪代码。
【实验报告补充要求】
1、熟悉 PhilosopherThread(LPVOID pVoid)函数，写出其伪代码（写入实验报告）
2、在VC++6.0环境下编译哲学家就餐问题演示程序后，考虑其他解决死锁方法。