课程名称：

实验序号：

实验名称：

班 级：深 圳 大 学 实 验 报 告 计算机基础（理论课） 实验2 操作系统与工具软件 姓 名：

同 组 人： 实验日期： 年 月 日

一、实验目的

1.能够正确分辨现代计算机系统的主要板卡、部件和设备，加深对微机的基本组成和工作原理的理解。

2.熟悉计算机板卡、部件和外设之间的连接，理解数据流向及变化。

3.学会基本的故障分析以及排除方法。

二、实验环境

1硬件环境：操作系统名称 Microsoft Windows 7 旗舰版 教师签字：

版本 6.1.7600 版本 7600

其他操作系统描述 不可用

操作系统制造商 Microsoft Corporation

系统名称 LENOVO-PC

系统制造商 LENOVO

系统模式 23473R9

系统类型 x64-based PC

处理器 Intel(R) Core(TM) i5-3230M CPU @ 2.60GHz，Mhz，2 个内核，4 个逻辑处理器

BIOS 版本/日期 LENOVO G1ET92WW (2.52 ), 2013/2/14 SMBIOS 版本 2.7

Windows 目录 C:\Windows

系统目录 C:\Windows\system32

启动设备 \Device\HarddiskVolume1

区域设置 中华人民共和国

硬件抽象层 版本 = "6.1.7600.16385"

用户名称 lenovo-PC\lenovo

时区 中国标准时间

已安装的物理内存(RAM) 4.00 GB

总的物理内存 3.70 GB

可用物理内存 1.79 GB

总的虚拟内存 7.41 GB 2601

可用虚拟内存

页面文件空间 5.23 GB 3.70 GB

页面文件 C:\pagefile.sys

2软件环境：WindowsXP 中文版

三、实验步骤

1.阅读随机使用手册

A对于装机用户

①装机箱电源；

②按照主板说明书设置主板跳线

③安装主板；

④在主板上安装CPU及其散热风扇，并安装内存条； ⑤连接电源线

⑥安装显卡、声卡、网卡

⑦安装软驱、光驱、硬盘

⑧连接机箱面板上的指示灯、开关

⑨连接键盘、鼠标、显示器、音箱

⑩连接外接电源

B对于成品机用户

认真阅读使用手册、随机光盘（内含主板.显卡、声卡等各种

驱动程序）、附件清单等技术资料。

2.硬件参数BIOS设置

在开机启动时，按Del键进入BIOS界面设置， BIOS程序中主要设置选项如下：

STANDARD CMOS SETUP（标准CMOS设定）：用来设定日期、时间、软硬盘规格、工作类型以及显示器类型 BIOS FEATURES SETUP（BIOS功能设定）：用来设定BIOS的特殊功能，例如病毒警告、开机磁盘优先程序等等。 CHIPSET FEATURES SETUP（芯片组特性设定）：用来设定CPU工作相关参数。

POWER MANAGEMENT SETUP（省电功能设定）：用来设定CPU、硬盘、显示器等等设备的省电功能。

PNP/PCI CONFIGURATION（即插即用设备与PCI组态设定）：用来设置ISA以及其它即插即用设备的中断以及其它差数。

LOAD BIOS DEFAULTS（载入BIOS预设值）：此选项用来载入BIOS初始设置值。

LOAD OPRIMUM SETTINGS（载入主板BIOS出厂设置）：这是BIOS的最基本设置，用来确定故障范围。

INTEGRATED PERIPHERALS（内建整合设备周边设定）：主板整合设备设定。

SUPERVISOR PASSWORD（管理者密码）：计算机管理员设置进入BIOS修改设置密码。

USER PASSWORD（用户密码）：设置开机密码。

IDE HDD AUTO DETECTION（自动检测IDE硬盘类型）：用来自动检测硬盘容量、类型。

SAVE&EXIT SETUP（储存并退出设置）：保存已经更改的设置并退出BIOS设置。

EXIT WITHOUT SAVE（沿用原有设置并退出BIOS设置）：不保存已经修改的设置，并退出设置。

按需要进行设置后退出设置。

3.硬盘初始化

(1)硬盘的分区操作

将系统软盘(Windows启动盘、DOS盘等)插入软驱，开机引导出现DOS提示符时，键人“FDISK” 命令按回车键，屏幕上出现四个选项： 1．reate DOS partition or logical DOS drive (建立DOS分区或逻辑分区) 2．Set active partition (设定对话框) 3．Delete partition information (删除DOS分区或逻辑分区) 4．Display partition information (显示分区信息) 键入“1”后，可以看到3个子选项： 1．Create primary DOS partition (创建基本DOS分区) 2．Create extended DOS partition (创建扩展DOS分区) 3．Create logical DOS drives in the extended DOS partition (在扩展分区中创建逻辑分区) 键人“3”后出现4个子选项：

1．Delete primary DOS partition (删除基本DOS分区)

2．Delete extended DOS partition (删除扩展DOS分区)

3．Delete logical DOS drives in the extended partition (删除扩展DOS分区中的逻辑分区) 4．Delete Non-DOS partition (删除非DOS分区) 键入“4”后可以看到硬盘的分区信息、容量分配等。

(2)格式化硬盘 把硬盘分区后，接下来对各个分区进行格式化。格式化命令基本格式为： FOR_MAT[驱动器：／参数] 如：FORMAT A：／Q FORMAT C：／S

4.安装操作系统（Windows XP）

1.BIOS参数的设置

2.运行安装光碟

3.设置安装分区

4.复制安装文件

5.重启计算机

6.设置安装信息

7.安装组件

8.重启并完成安装

5.安装设备驱动程序

三种方式：

①直接执行驱动程序盘中的安装程序，如Setup.exe程序； ②通过[设备管理器]找到需要安装驱动程序的设备，然后

启用或更新驱动程序；

③通过[添加新硬件]向导完成新硬件inf文件的安装。

6.安装应用软件

①阅读应用软件附带的说明性文件或程序README，了解和掌握相应软件的安装和使用方法。

②，用文件管理器或相应的搜索查找软件安装执行程序，如Setup、Install等，找到后双击鼠标左键执行。

③根据软件安装向导或热键帮助功能的指示进行安装。 ④利用[控制面板]中的[添加/删除程序]完成添加或删除Windows组件或应用软件

四．结果与分析

结果：

1.阅读随机使用手册：熟悉了相关计算机知识和基本操作。

2.硬件参数BIOS设置：熟悉了BIOS程序中的主要设置，成功设置了相关BOIS设置

3.硬盘初始化：成功将硬盘初始化

4.安装操作系统：成功安装操作系统

5.安装设备驱动程序：成功完成设备驱动程序的安装

6.安装应用软件：成功安装应用软件

五、思考题解答 1.通常组装一台PC机需要哪些配件？

答：主板、CPU内存、显卡、机箱+电源、显示器、鼠标键盘

2.BIOS和CMOS有什么区别？

答：BIOS是软件、是程序，而CMOS是芯片、是硬件

3.简述硬盘分区和硬盘格式化方法？

格式化：进入系统 我的电脑--右键--管理---磁盘管理，右边会显示，点击新的硬盘--右键--格式化

六、心得体会

通过学习，实验与观看视频，我们小组了解了计算机的基本结构和计算机的安装与设置的基本步骤，这次实验让我们学习到了更多关于计算机的知识并且拓展了我们的知识面，还让我们小组的成员在学习中增加了相互了解的机会，培养了相互合作的良好态度，在这次试验中我们小组的成员都得到了很大的益处。

 

第二篇：操作系统实验报告

 

                  目录

一、 需求分析…………………………………………………2

二、 系统概要设计……………………………………………2

三、系统详细设计………………………………………………4

四、系统主要源代码……………………………………………5

五、系统测试及调试……………………………………………5

六.、心得体会……………………………………………………8

七、参考文献……………………………………………………9

八、附录…………………………………………………………9

         

操作系统课程设计报告

课设内容简介：

银行家算法的模拟实现。

一、需求分析

控制工作流程 ，管理资源，为用户服务，是操作系统的主要功能。在资源管理中，操作系统的任务是使各种系统资源得到充分合理的应用，解决用户作业因资源而产生的矛盾，并合理的让用户再合适的时间内得到其应有的服务。

现代操作系统引入了多道程序设计技术，允许锁个进程同时驻留内存并发执行。若干个进程将不可避免地竞争系统资源，如果操作系统不能够协调多个进程对系统资源的竞争与共享，将会导致执行结果异常，系统不稳定、失效等多种问题，从而产生死锁，产生死锁的原因可分为两种：（1）竞争资源引起死锁（2）进程推进顺序不当引起死锁。

银行家算法是一种代表性的避免死锁的算法，在进程申请资源的时候，系统调用银行家算法来检测此次分配会不会导致死锁的产生，及判断此次分配的安全性。若检测到此次分配是安全的则分配给申请进程所申请的资源，若检测到此次分配是不安全的，则相应的进程等待。

二、系统概要设计

（1）系统主要功能：系统运用银行家算法先对用户提出的计算机系统资源请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查，后决定是否给相应进程动态分配资源。

（2）系统模块功能结构：

 

（3）运行环境要求：

相关工具：

Microsoft Visual C++ 6.

（4）数据结构设计及相关说明：
 （1）、可利用资源向量  INT  AVAILABLE[M]  M为资源的类型。
 （2）、最大需求矩阵    INT  MAX[N][M]  N为进程的数量。
 （3）、已分配矩阵      INT  ALLOCATION[N][M]
 （4）、还需求矩阵      INT  NEED[N][N]
 （5）、申请各类资源数量int Request[x]; //
 （6）、工作向量        int Work[x];
  （7）、int Finish[y]; //表示系统是否有足够的资源分配给进程，0为否，非0为是
                三、系统详细设计

 （1）、系统初始化。输入进程数量，资源种类，各进程已分配、还需求各资源数量，各资源可用数量等
 （2）、输入用户的请求三元组（I，J，K），为进程I申请K个J类资源。
 （3）、检查用户的请求是否小于还需求的数量，条件是 K<=NEED[I,J]。如果条件不符则提示重新输
    入，即不允许索取大于需求量
 （4）、检查用户的请求是否小于系统中的可利用资源数量，条件是K<=AVALIABLE[I,J]。如果条件不
 符则申请失败，阻塞该进程，重新进行进程动态资源申请（使用goto语句）
 （5）、进行资源的预分配，语句如下：
 AVALIBLE[I][J]= AVALIBLE[I][J]-K；
 ALLOCATION[I][J]= ALLOCATION[I][J]+K；
 NEED[I][J]=NEED[I][J]-K；
    （6）、系统调用安全性检查算法（safe()函数）进行检查，如果检查通过，则不用回收，否则进行
 回收，进程资源申请失败进入等待。
4、安全性检查算法（safe()子函数）
    （1）、设置两个临时变量。
    （2）、在进程中查找符合以下条件的进程。
           条件1：FINISH[I]=0
     条件2：NEED[I][J]〈=WORK[J]
    （3）、如果查找成功则进行资源的模拟回收，语句如下：
           WORK[J]=WORK[J]+ALLOCATION[I][J]；
     FINISH[I]=1 或查找到的顺序号
    （4）、如果查找不成功，则检查所有进程的FINISH[]，如果有一个为0，则系统不为0，返回不成功
 标志。否则返回成功标志。

四、系统主要原代码见附录！！

五、系统测试及调试

5.1  

5.3  出现问题及解决方案：

本程序考虑了程序功能实现、格式显示合理化、输入错误异常处理等各个方面的设计，尽可能使程序设计的更加完美。在长期的设计调试过程中遇到过许多问题，通过网上搜索、查询资料、调试试验等方法一一解决。下面大致罗列一些主要问题：

5.3.1关于输入错误的异常处理：数字判断

在调试程序过程中我们都知道在要求输入整型数据时，如不小心键入字母符号等，则程序立即出错；还有如在要求输入一个字符时，如果不小心输入为了字符串，则也会出错（此时多键入的字符被保留在缓冲区内，当下次要求屏幕输入时先从缓冲区取出导致出错）。因此设计了一个判断函数int shuzi(int n); 进行处理此类输入异常错误。此函数主要设计思路为：定义一个动态字符串指针，输入后判断每个输入的字符是否在’0’—‘9’ 之间来判断是否输入的为数字字符，然后按照字符ASCII码值与数字值的关系将输入的字符转换为整数。

而对于字符输入的问题，可以定义为一个动态字符串指针然后只取输入的第一个字符内容。

5.3.2关于某些判断算法优劣问题：

在程序中很多地方都会用到循环判断是否符合条件的算法，在设计这些算法时有很多方法，而有的算法可以更节省时间。如下安全性算法中寻找寻找符合Finish[i]==0条件的进程的例子：

/* 算法一： 

           for (j=0; j<m; j++)

                 if (Work[j]>=Need[i][j]) counter=counter+1;//记数

           if(counter==m){…

*/ //算法二：

           for (j=0; j<m; j++)

                 if (Work[j]>=Need[i][j]); //可用大于等于需求

                else{

                      counter=1;

                      break;

                 }

           if(counter!=1){…

显然算法二要优于算法一。本程序中还有很多类似的地方。这里主要考虑的是一个程序的优化设计问题。

六、心得体会

在设计此程序的过程中，我遇到过许多问题，也学到了很多东西。本程序的设计实现主要是用C++语言实现，通过对程序算法的设计优化、输出显示的格式设计、输入过程中的异常处理等一些设计过程中的问题的考虑解决，在C++学习上也有了很大的进步。程序设计过程中开始遇到的最大的问题是算法的结构设计问题，课本上只给了设计要求及简单的算法，要真正实现还需要考虑很多方面。在算法的数据结构设计上考虑了很长时间。在程序设计中先后参考了很多网络资料，也参考了一些别人写的的程序，综合这些算法思想和自己的思路对程序做了很好的设计方式，对一些算法的优越性等也作了一些考虑。此外考虑最多的就是异常错误处理的设计。一个好的程序必须能在各种环境下都有其相应的处理方式，至少能应对一些常见的可能发生的错误。在课程设计过程中遇到了许多问题，也向同宿舍的同学做了一些请教一起讨论，也因此从他们身上学到了许多东西。

七、参考文献

[1] 汤子瀛等.《计算机操作系统》.西安：西安电子科技大学出版社，2006.10.

[2] 刘璟等. 《高级语言c++程序设计》.北京：高等教育出版社，2006.03.

[3] 胡志刚、谭长庚. 计算机操作系统.中南大学出版社.2005.7

[4] 张尧学. 计算机操作系统教程（第二版）. 清华大学出版社. 2000.8

                  八、附录

#include <iostream.h>
#include <stdio.h>
#include <stdlib.h> 
#include <conio.h>
#include <string.h>

//===定义全局变量===
const int x=50,y=100; 

int Available[x];     

int Allocation[y][y]; 

int Max[y][y]; 
int Need[y][y];
int Request[x];
int Work[x];
int Finish[y];
int p[y];

 int i,j;
int n,m;  //n为进程的数量,m为资源种类数
int l=0,counter=0;
//函数声明
int shuzi(int sz); 

void chushihua();  //系统初始化函数
void safe();       //安全性算法函数
void bank();       //银行家算法函数
void showdata();  

//===数字判断函数===
int shuzi(int sz){ 

char *temp;
    temp=new char;  

    int len;
    sz=0 ; //清零
    char s; //
    do{                                                                                 
       // gets(temp);   //getline(cin,temp)
  cin>>temp;
        len=strlen(temp);    

        for(int i=0;i<len;i++){       
           s= *(temp+i);
           if(s<'0' || s>'9'){          
               cout<<" 抱歉，输错了! 你输入的是数字吗?! \n\n";
      cout<<"请重新输入：";
      break;
           }         
        }
    }while(s<'0' || s>'9');  
    for(int i=0;i<len;i++){       /

         int t=1; 
        for(int j=1;j<len-i;j++) t*=10;
        sz+=(*(temp+i)-48)*t;  
    }
 return sz;
}
//===系统初始化函数===
void chushihua(){ 
 //===系统初始化输入===
 cout<<"%% 程序开始，系统初始化输入 %%"<<endl;  //<<endl
    cout<<"==============================================================="<<endl<<endl;
    cout<<"请输入进程的数量: "

    n=shuzi(n);
    cout<<"请输入资源种类数: ";
 m=shuzi(m);

    cout<<endl<<endl<<"请输入各种资源可利用的数量( "<<m<<" 种): "<<endl;
  cout<<endl; 
 for (j=0; j<m; j++){
  cout<<"   输入资源 "<<j<<" 可利用的数量Available["<<j<<"]: ";
  Available[j]=shuzi(Available[j]);
        Work[j]=Available[j];          //初始化Work[j]
 // cout<<endl;
 }

 //system("cls");  //清屏
 cout<<endl;

 cout<<"请输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl<<endl;
 for (i=0; i<n; i++){
  for (j=0; j<m; j++){
   cout<<"   请输入进程 "<<i<<" 当前已分配的资源 "<<j<<" 数量: ";
   Allocation[i][j]=shuzi(Allocation[i][j]);
   }
  cout<<endl;
  Finish[i]=0;//初始化Finish[i]
  //break;
 }
 cout<<endl<<endl;

 cout<<"请输入各进程对各类资源的最大需求数Max["<<n<<"]["<<m<<"]: "<<endl<<endl;
 for (i=0; i<n; i++){
  for (j=0; j<m; j++) {
   cout<<"   请输入进程 "<<i<<" 对资源 "<<j<<" 的最大需求数: ";
   Max[i][j]=shuzi(Max[i][j]);
   if(Max[i][j]>=Allocation[i][j])  //
    Need[i][j] = Max[i][j]-Allocation[i][j];  //计算还需求量
   else
    Need[i][j]=0;

  }
  cout<<endl;
 }

    cout<<endl<<"%% 初始化完成! %%"<<endl;
}

//===安全性算法函数===
void safe(){
 l=0; 
 for (i=0; i<n;){  //i++ 
  if (Finish[i]==0){  //寻找Finish[i]==0的进程    条件一
   counter=0;   //记数器
 for (j=0; j<m; j++)
    if (Work[j]>=Need[i][j]);  //可用大于等于需求
                else{
     counter=1;
     break;
    }

   if(counter!=1){ //进程的每类资源量都符合条件Work[j]>=Need[i][j]   条件二
    p[l]=i;  //存储安全序列
                Finish[i]=1; 

for (j=0; j<m;j++){
     Work[j]=Work[j]+Allocation[i][j]; 
    }
    l=l+1;
    i= -1;

   }
  }
  i++;
 }
}
//===显示分配情况函数 ===
void showdata() //函数showdata,输出当前资源分配情况
{
    int i,j; //局部变量
 int All[y]; //各种资源的总数量
 int l2; //局部变量      l1,
 
   cout<<"==============================================================="<<endl<<endl;
 cout<<"%% 系统当前状态如下：%%"<<endl<<endl;

cout<<"%% 各种资源的总数量(all):"<<endl; 
    for (j=0;j<m;j++) {
  cout<<" 资源"<<j<<": ";
  All[j]=Available[j]; 
  for (i=0;i<n;i++){
   All[j]+=Allocation[i][j];

  cout<<All[j]<<"  ";
  if ((j+1)%5==0 ) cout<<endl;  //每行显示五个     && j!=0
 }
    cout<<endl<<endl;

    cout<<"%% 系统目前各种资源可用的数为(available):"<<endl;

    for (j=0;j<m;j++){
  cout<<" 资源"<<j<<": "<<Available[j]<<"  ";
  if((j+1)%5==0) cout<<endl; //每行最多显示五个     && j!=0
 }
    cout<<endl<<endl;

    cout<<"%% 各进程已经得到的资源量(allocation): "<<endl;
// l1=0;  //归零
 for(i=0;i<=m/5;i++){ 
  for (j=i*5;j<i*5+5 && j<m;j++)cout<<"      资源"<<j;
  cout<<endl;
  for(l2=0;l2<n;l2++){
   cout<<"进程"<<l2<<":";
   for (j=i*5;j<i*5+5 && j<m;j++)cout<<Allocation[l2][j]<<"          ";
      cout<<endl;
  }
 }
 cout<<endl;

    cout<<"%% 各进程还需要的资源量(need):"<<endl;     //<<endl
 //l1=0;
 for(i=0;i<=m/5;i++){  //设计每行显示五种资源
  for (j=i*5;j<i*5+5 && j<m;j++)cout<<"      资源"<<j;
  cout<<endl;
  for(l2=0;l2<n;l2++){
   cout<<"进程"<<l2<<":";
   for (j=i*5;j<i*5+5 && j<m;j++)cout<<Need[l2][j]<<"          ";
      cout<<endl;
  }
 }
 //===银行家算法函数===
void bank(){
 cout<<"==============================================================="<<endl<<endl;
 cout<<"%% 以下开始为进程进行资源分配申请 %%"<<endl<<endl;
 //===申请资源===
 int k=0;//用于输入进程编号
 bool r=false;  // 初值为假，输入Y继续申请则置为真

 do{
        //输入请求
  cout<<"请输入申请资源的进程编号(输入0--"<<n-1<<"之间): ";
  k=shuzi(k);
  cout<<endl;
  while(k>n-1) { //输入异常处理
   cout<<endl<<"您输入了错误的进程号，请重新输入!"<<endl;
   cout<<endl<<"请输入申请资源的进程编号(输入0--"<<n-1<<"之间): ";
      k=shuzi(k);
   cout<<endl;
  }

  cout<<endl<<"请输入该进程申请各类资源的数量: "<<endl;
  for (j=0; j<m; j++){

   do{ 

cout<<"进程 "<<k<<" 申请资源["<<j<<"]的数量:";
       Request[j]=shuzi(Request[j]);
    cout<<endl;
    if(Request[j]>Need[k][j]){ 

        cout<<"申请大于需要量!!!"<<endl;
        cout<<"您申请资源"<<j<<"的数量为"<<Request[j]<<",大于进程"<<k<<"对该资源需求量"<<Need[k][j]<<"。"<<endl;
        cout<<"请重新输入!!!"<<endl;
    }
    else  
     if(Request[j]>Available[j]){ 

cout<<"\n没有那么多资源，目前可利用资源"<<j<<"数量为"<<Available[j]<<",本次申请不成功，进程等待!!!"<<endl;
      Finish[k]=0;  //该进程等待
      goto ppp; 

     }

   }while(Request[j]>Need[k][j]);  //Request[j]>Available[j]||
  }

  //改变Avilable、Allocation、Need的值
  for (j=0; j<m; j++) {
   Available[j] = Available[j]-Request[j];
   Allocation[k][j] = Allocation[k][j]+Request[j];
   Need[k][j] = Need[k][j]-Request[j];
   Work[j] = Available[j];
  }

       //判断当前状态的安全性
  safe();  //调用安全性算法函数
  if (l<n) {
   l=0; 
   cout<<"\n当前状态不安全,不予分配!!!!!!"<<endl;
   //恢复数据
   for (j=0; j<m; j++) {
    Available[j] = Available[j]+Request[j];
    Allocation[k][j] = Allocation[k][j]-Request[j];
    Need[k][j] = Need[k][j]+Request[j];
    Work[j] = Available[j];
   }
   for (i=0; i<n; i++)
    Finish[i]=0;  /

  }
  else{
  // system("cls");
   l=0; 
            cout<<"\n申请资源成功!!!"<<endl;

//===========================================
/* 

   for(j=0;j<m;j++) if(Need[k][j]==0) l=l+1;
   if(l==m){                                 //此处借用 l 做下计数器
    for (j=0;j<m;j++){  

     Available[j]=Available[j]+Max[k][j];
     Allocation[k][j]=0; 
    }
   }
   l=0;  //归零
//===========================================

            cout<<"\n安全的状态!!!"<<endl;
            cout<<"安全序列为:   ";
      cout<<endl<<"进程"<<"("<<p[0]<<")"; 

      Finish[0]=0;
      for (i=1; i<n; i++){
       cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
                Finish[i]=0; //所有进程置为未分配状态
   }
   cout<<endl<<endl;
  }

  showdata();  //显示当前状态

ppp:   //申请大于可利用量， 应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此
  cout<<endl<<"是否继续申请资源(y/n) ?";
  char* b=new char;  //输入y/n，判断是否继续申请    <<endl
  cin>>b;
  cout<<endl;
     cout<<"==============================================================="<<endl<<endl;
        cout<<endl;

  if(*b=='y'||*b=='Y')
   r=true;
  else{
   r=false;  //输入非 Y 则令 R =false
  // system("cls");  //在sign() 里调用
   sign(); 
  }
    } while (r==true);
}

//===主函数===
 int main(){  // void main()
 system("color 06f"); //设置当前窗口的背景色和前景色 0 = 黑色 8 = 灰色

    chushihua(); //初始化函数调用
    cout<<endl<<endl;
 showdata();  //输出初始化后的状态

    //===判断当前状态的安全性===
 safe();  //安全性算法函数调用

 if (l<n){
  cout<<"\n当前状态不安全，无法申请,程序退出!!!!!"<<endl;
  cout<<endl;
  system("pause");
 // cin>>l;

 return 0;  // break;
 }
 else{
  int i;  //局部变量
  l=0;
        cout<<"\n安全的状态!!!"<<endl;
        cout<<"安全序列为:   ";
 
  cout<<endl<<"进程"<<"("<<p[0]<<")";  //输出安全序列，考虑显示格式，先输出第一个
  for (i=1; i<n; i++){
   cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
  }
  for (i=0; i<n; i++) Finish[i]=0;  //所有进程置为未分配状态
  cout<<endl<<endl;
 }
 
 bank();    //银行家算法函数调用
    return 0; // break;
}