进程同步及避免死锁经典问题

定义PV操作的含义：PV操作是由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：
    P（S）：将信号量S的值减1，即S=S-1；如果S>0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。
    V（S）：将信号量S的值加1，即S=S+1；如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。
P操作相当于申请资源，而V操作相当于释放资源。

一、读者-写者问题

计算机系统中的数据（文件、记录）常被多个进程共享，但其中某些进程可能只要求读数据（称为读者Reader），另一些进程则要求修改数据（称为写者Writer）。就共享数据而言，Reader和Writer是两组并发进程共享一组数据区，要求：

（1）允许多个读者同时执行读操作；
（2）不允许读者、写者同时操作；
（3）不允许多个写者同时操作。
Reader和Writer的同步问题分为读者优先、弱写者优先（公平竞争）和强写者优先三种情况，它们的处理方式不同：

1、读者优先

int rc = 0; //记录有多少个读者在读semaphore rc_semaphore = 1; //对rc互斥访问的信号量semaphore write_semaphore = 1; //保证读写互斥的信号量void reader(){do {P(rc_semaphore);rc++;if(1==rc)P(write_semaphore);V(rc_semaphore);read operating.....    P(rc_semaphore);rc--;if(0==rc)V(write_semaphore);v(rc_semaphore);} while (true);}void writer(){do {P(write_semaphore);write operating.....V(write_semaphore);} while (true);}

缺点：当不断有读者来读取时，写者就会陷入无限的等待。

2、写者优先（弱优先性）

int rc = 0; //记录有多少个读者在读semaphore rc_semaphore = 1; //对rc互斥访问的信号量semaphore write_semaphore = 1; //保证读写互斥的信号量semaphore read_semaphore = 1;void reader(){do {P(read_semaphore);P(rc_semaphore);rc++;if(1==rc)P(write_semaphore);V(rc_semaphore);V(read_semaphore);Reading the file....P(rc_semaphore);rc--;if(0==rc)V(write_semaphore);V(rc_semaphore);} while (true);}void writer(){do {P(read_semaphore);P(write_semaphore);writing the file.....V(write_semaphore);V(read_semaphore);} while (true);}

缺点：这个是按照先来先服务的原则进行读写的，比如当一个进程在写时，来了N个进程读，读者们都在等写者结束，此时又来了个写者，第二个写者就要等前面N个读者读完后才能写。

3、写者优先（强优先性）

int rc = 0;int wc = 0;semaphore write_semaphore = 1;semaphore rc_semaphore =1;semaphore wc_semaphore = 1;void reader(){do {P(read_semaphore);P(rc_semaphore);rc++;if(1==rc)P(write_semaphore);V(rc_semaphore);V(read_semaphore);reading the file.....P(rc_semaphore);rc--;if(0==rc)V(write_semaphore);V(rc_semaphore);} while (true);}void writer(){do {P(wc_semaphore);wc++;if(1==wc)P(read_semaphore);V(wc_semaphore);P(write_semaphore);writing the file......V(write_semaphore);P(wc_semaphore);wc--;if(0==wc)V(read_semaphore);V(wc_semaphore);} while (true);}

保证了写者优先，只要有写者在写，后来的读者写者中优先执行写者。

二、生产者-消费者

生产者-消费者问题指的是在若干个生产者生产产品，放入共享的缓冲区，若干消费者从缓冲区中取出产品消费；生产者和消费者是互斥访问共享的缓冲区的，若缓冲区没有空位生产者要等待，若缓冲区没有产品消费者要等待，以下通过代码来演示这个过程。

注：以下代码修改自http://blog.sina.com.cn/s/blog_58069bd20100as5w.html

#include <windows.h>#include <iostream>using namespace std;const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度unsigned short ProductID = 0; //产品号unsigned short ConsumeID = 0; //将被消耗的产品号unsigned short in = 0; //产品进缓冲区时的缓冲区下标unsigned short out = 0; //产品出缓冲区时的缓冲区下标int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列HANDLE g_hMutex; //用于线程间的互斥HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待DWORD WINAPI Producer(LPVOID); //生产者线程DWORD WINAPI Consumer(LPVOID); //消费者线程int main(){//创建各个互斥信号g_hMutex = CreateMutex(NULL,FALSE,NULL);g_hFullSemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER,NULL);g_hEmptySemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);//调整下面的数值，可以发现，当生产者个数多于消费者个数时，//生产速度快，生产者经常等待消费者；反之，消费者经常等待const unsigned short PRODUCERS_COUNT = 3; //生产者的个数const unsigned short CONSUMERS_COUNT = 2; //消费者的个数//总的线程数const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;HANDLE hThreads[THREADS_COUNT]; //各线程的handleDWORD producerID[PRODUCERS_COUNT]={1,2,3}; //生产者线程的标识符DWORD consumerID[CONSUMERS_COUNT]={1,2}; //消费者线程的标识符//创建生产者线程for (int i=0;i<PRODUCERS_COUNT;++i){hThreads[i]=CreateThread(NULL,0,Producer,&producerID[i],0,NULL);if (hThreads[i]==NULL) return -1;}//创建消费者线程for (int i=0;i<CONSUMERS_COUNT;++i){hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,&consumerID[i],0,NULL);if (hThreads[i]==NULL) return -1;}while(true){Sleep(10000);}return 0;}//生产一个产品。简单模拟了一下，仅输出新产品的ID号void Produce(){std::cerr << "Producing " << ++ProductID << " ... ";std::cerr << "Succeed" << std::endl;}//把新生产的产品放入缓冲区void Append(){std::cerr << "Appending a product ... ";g_buffer[in] = ProductID;in = (in+1)%SIZE_OF_BUFFER;std::cerr << "Succeed" << std::endl;//输出缓冲区当前的状态for (int i=0;i<SIZE_OF_BUFFER;++i){std::cout << i <<": " << g_buffer[i];if (i==in) std::cout << " <-- 生产";if (i==out) std::cout << " <-- 消费";std::cout << std::endl;}}//从缓冲区中取出一个产品void Take(){std::cerr << "Taking a product ... ";ConsumeID = g_buffer[out];g_buffer[out] = 0;out = (out+1)%SIZE_OF_BUFFER;std::cerr << "Succeed" << std::endl;//输出缓冲区当前的状态for (int i=0;i<SIZE_OF_BUFFER;++i){std::cout << i <<": " << g_buffer[i];if (i==in) std::cout << " <-- 生产";if (i==out) std::cout << " <-- 消费";std::cout << std::endl;}}//消耗一个产品void Consume(){std::cerr << "Consuming " << ConsumeID << " ... ";std::cerr << "Succeed" << std::endl;}//生产者DWORD WINAPI Producer(LPVOID lpPara){while(true){WaitForSingleObject(g_hEmptySemaphore,INFINITE);WaitForSingleObject(g_hMutex,INFINITE);Produce();Append();Sleep(3000);ReleaseMutex(g_hMutex);ReleaseSemaphore(g_hFullSemaphore,1,NULL);}return 0;}//消费者DWORD WINAPI Consumer(LPVOID lpPara){while(true){WaitForSingleObject(g_hFullSemaphore,INFINITE);WaitForSingleObject(g_hMutex,INFINITE);Take();Consume();Sleep(3000);ReleaseMutex(g_hMutex);ReleaseSemaphore(g_hEmptySemaphore,1,NULL);}return 0;}

三、哲学家进餐

问题描述：

五个哲学家围坐在一张圆桌周围，每个哲学家面前都有一盘通心粉。由于通心粉很滑，所以需要两把叉子才能夹住。相邻两个盘子之间放有一把叉子，哲学家的生活中有两种交替活动时段：即吃饭和思考。当一个哲学家觉得饿了时，他就试图分两次去取其左边和右边的叉子，每次拿一把，但不分次序。如果成功地得到了两把叉子，就开始吃饭，吃完后放下叉子继续思考。关键问题是：能为每一个哲学家写一段描述其行为的程序，且决不会死锁吗(最好能达到最大的并行程度)？

解法思路：

1、为每个哲学家分配一个semaphore[i]初始值为0，最大值为1

2、当一个哲学家试图进餐时先通过互斥量获得对哲学家们的状态state的独占性访问         

3、改变i哲学家的状态为HUNGRY，测试其左右哲学家是否在用餐，若左右哲学家都不在用餐，则i哲学家可以用餐，改变state[i]=EATING,释放其semaphore[i]，释放state，拿起餐插成功进餐；若左右哲学家有人在进餐，释放state，i哲学家等待

4、哲学家用餐完毕，获取对state的独占性访问，改变state[i]=THINKING，此时i哲学家释放了两个餐插，测试其左右哲学家是否在HUNGRY状态

5、重复2-4步骤直到达到最大进餐次数

参考如下代码：(以下代码修改自http://blog.163.com/diaoshuo_1/blog/static/318902012009418115121514/)

/*Item       The Dining Philosophers Problem具体要求1) 5个哲学家，先吃饭，后思考。2) 每个哲学家都需要吃9顿饭，思考9次，然后结束。3）吃饭时间为3~7秒的随机时间4）思考时间为3~9秒的随机时间*/#include <windows.h>#include <time.h>#include <stdlib.h>#include <stdio.h>#define N       5            //哲学家数目#define MAXNUM 9     //进餐思考次数#define LEFT (i+N-1)%N            //i为左邻居编号#define RIGHT      (i+N+1)%N           //i为右邻居编号#define THINKING       0                          //哲学家在思考#define HUNGRY  1                                 //哲学家视图拿起叉子#define EATING    2                                 //哲学家进餐///////线程参数typedef struct _THREAD_ARGS{int id;//哲学家编号int maxnum; //进餐思考最大次数}THREAD_ARGS, *PTHREAD_ARGS;int state[N];//用来记录每位哲学家的状态int g_philobuf_fork_num;//缓冲区中叉子数目char mutex_g_buf[]="PS_IPC_PHILO_G_BUF";HANDLE mutex_g_buf_h;  //为了互斥访问state[N]//Semaphores' Namechar* sem_perphilo_name[N] = {"PS_IPC_PHILO_SEM_PERPHILO_0","PS_IPC_PHILO_SEM_PERPHILO_1","PS_IPC_PHILO_SEM_PERPHILO_2","PS_IPC_PHILO_SEM_PERPHILO_3","PS_IPC_PHILO_SEM_PERPHILO_4"};HANDLE sem_perphilo_h[N];   //每个哲学家一个semaphore,初始值为0，最大值为1DWORD WINAPI philosopher(void *pArgs);void take_forks(int i);void put_forks(int i);void test(int i);//线程函数DWORD WINAPI philosopher(void *pArgs){PTHREAD_ARGS pTHREAD_ARGS;pTHREAD_ARGS=(PTHREAD_ARGS)pArgs;int i=pTHREAD_ARGS->id;int totalNum = pTHREAD_ARGS->maxnum;for(int count=0;count<totalNum;count++){take_forks(i);srand ((DWORD)time(NULL));int eat_t=rand()%4000 + 3000;Sleep(eat_t);printf("Philosopher %d finishes eating!this is the %d(th) eating time! eat_t:%d\n",i,count+1,eat_t);put_forks(i);srand ((DWORD)time(NULL));int think_t= rand()%6000 + 3000;Sleep(think_t);printf("Philosopher %d finishes thinking!this is the %d(th) thinking time! think_t:%d\n",i,count+1,think_t);}printf("Philosopher %d has finished all the eating and thinking activity\n!",i);return 0;}void take_forks(int i){WaitForSingleObject(mutex_g_buf_h,INFINITE);state[i]=HUNGRY;printf("*************************take_forks start***************************\n");printf("Philosopher %d is hungry!  Try to take the forks\n",i);printf("*************************take_forks end***************************\n\n");test(i);ReleaseMutex(mutex_g_buf_h);WaitForSingleObject(sem_perphilo_h[i],INFINITE);}void put_forks(int i){WaitForSingleObject(mutex_g_buf_h,INFINITE);state[i]=THINKING;g_philobuf_fork_num=g_philobuf_fork_num-2;//放下了两把叉子printf("*************************put_forks start***************************\n");printf("Philosopher %d puts down the fork and starts thinking! current forks num:%d\n",i,g_philobuf_fork_num);printf("*************************put_forks end***************************\n\n");test(LEFT);test(RIGHT);ReleaseMutex(mutex_g_buf_h);}void test(int i){LONG oldSemValue;if(state[i]==HUNGRY&&state[LEFT]!=EATING&&state[RIGHT]!=EATING){state[i]=EATING;g_philobuf_fork_num=g_philobuf_fork_num+2;//拿起了两把叉子printf("*************************test start***************************\n");printf("After testing,Philosopher %d can starts eating! current forks num:%d\n",i,g_philobuf_fork_num);printf("*************************test end***************************\n\n");ReleaseSemaphore(sem_perphilo_h[i],1,&oldSemValue);}}int main(int argc,char*argv[]){time_t launch=time(NULL);printf("****************************************************\n");printf("开始运行时间：%s",ctime(&launch));printf("哲学家就餐问题\n");printf("哲学家数量：%d\n",N);printf("进餐思考次数：%d\n",MAXNUM);      printf("****************************************************\n");DWORD Status;DWORD *ThId_Philo=new DWORD[N];HANDLE *philo_h=new HANDLE[N];THREAD_ARGS *ThArgs_Philo=new THREAD_ARGS[N];//当前拿起的叉子数目g_philobuf_fork_num=0;mutex_g_buf_h=CreateMutex(NULL,FALSE,mutex_g_buf);int nCounter=0;for(nCounter=0;nCounter<N;nCounter++){sem_perphilo_h[nCounter]=(HANDLE)CreateSemaphore(NULL,0,1,sem_perphilo_name[nCounter]);}//CreateThreadfor(nCounter=0;nCounter<N;nCounter++){ThArgs_Philo[nCounter].id=nCounter;ThArgs_Philo[nCounter].maxnum=MAXNUM;philo_h[nCounter]=(HANDLE)CreateThread(NULL,0,philosopher,&ThArgs_Philo[nCounter],0,&ThId_Philo[nCounter]);}/* wait for all threads to terminate*/for(nCounter = 0; nCounter < N; nCounter++)Status = WaitForSingleObject(philo_h[nCounter], INFINITE);  for(nCounter=0;nCounter<N;nCounter++){CloseHandle(sem_perphilo_h[nCounter]);}CloseHandle(mutex_g_buf_h);system("pause");return 0;  }

四、银行家算法(避免死锁)

死锁产生的条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。

请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。（

不可剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。

环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

银行家问题描述：

银行家算法是避免死锁的一种重要方法，防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。通过这个算法可以用来解决生活中的实际问题，如银行贷款等。 

程序实现思路银行家算法顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。
把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。显然，，每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁. 

算法流程图：

Safe算法流程：

实例分析(参考操作系统书籍及http://www.cnblogs.com/xuxu8511/archive/2012/04/06/2435053.html)：

 某系统有R1，R2，R3共3中资源，在T0时刻P0，P1，P2，P3和P4这5个进程对资源的占用和需求情况如下表1，此时系统的可用资源向量为(3,3,2)。试问：

1、T0时刻系统是否存在安全序列？

2、P1请求资源：P1发出请求向量Request（1,0,2），系统是否接受该请求？请使用银行家算法检查

3、P4请求资源：P4发出请求向量Request（3,3,0），系统按银行家算法检查.

4、P0请求资源：P0发出请求向量Request（0,2,0），系统按银行家算法检查.

　　　　　　表1 T0时刻的资源分配表

MAXAllocationNeedAvailableP0           7 5 3        0 1 0        7 4 3         3 3 2        P13 2 2  　　2 0 01 2 2     
P29 0 23 0 26 0 0
P32 2 2　2 1 1 　0 1 1
P44 3 30 0 24 3 1

 

说明：

1、T0时刻系统是否存在安全序列？

Available > Need1 ----> 可用资源分配给P1，直到P1进程执行完成，然后Available = Available + Allocation1 = （5,3,2）

Available > Need3 -----> 可用资源分配给P3，直到P3进程执行完成，然后Available = Available + Allocation3 = （7,4,3）

Available> Need4.....

得到安全序列为：P1，P3，P4，P2，P0

2、P1请求资源：P1发出请求向量Request（1,0,2），系统是否接受该请求？请使用银行家算法检查

第一步（假分配检查）：把Request分配给P1，必须满足Request要小于Available，Request要小于Need。

                       Request（1,0,2）< Available（3,3,2）

                       Request（1,0,2）< Need（1,2,2）

        因为满足第一步检查，进入第二层检查（安全序列检查）。

第二步（安全序列检查）：建立安全性检查表

Work　　NeedAllocation　　Work+Allocation　　FinishP12 3 00 2 03 0 2

如果 Work > Need ,那么执行Work+Allocation，得到：　　　　　　　　　　　　　　　　

Work　　NeedAllocation　　Work+Allocation　　FinishP1  2 3 00 2 0    3 0 2 5 3 2 true
5 3 2    

　  找到Need<Work的进程，如果没有找到这样的进程而进程集合没有执行，则算法返回，得到不存在安全序列结果，否则继续执行该算法。

　  这里我们找到了P3进程。修改安全序列检查表：

Work　　NeedAllocation　　Work+Allocation　　FinishP1  2 3 00 2 0    3 0 2 5 3 2 trueP35 3 2    0 1 1　　2 1 1 7 4 3 true
7 4 3

　　这样一直执行到所有的进程到完成，以完成该安全序列检查表：

Work　　NeedAllocation　　Work+Allocation　　FinishP1  2 3 00 2 0    3 0 2 5 3 2 trueP35 3 2    0 1 12 1 1 7 4 3 trueP47 4 34 3 10 0 2 7 4 5 trueP07 4 57 4 30 1 0 7 5 5 trueP27 5 56 0 03 0 210 5 7 true

      这样就找到了整个安全序列为：P1，P3，P4，P0，P2

3、4小问也是同样的解题过程。这里不赘述...

代码实现(参考自http://blog.csdn.net/orange_os/article/details/7417204)：

/*以下代码仅是求出了一种可行序列，也许存在多种可行序列*/#include <iostream>using namespace std;#define MAXPROCESS 50                        /*最大进程数*/#define MAXRESOURCE 100                        /*最大资源数*/int AVAILABLE[MAXRESOURCE];                    /*可用资源数组*/int MAX[MAXPROCESS][MAXRESOURCE];            /*最大需求矩阵*/int ALLOCATION[MAXPROCESS][MAXRESOURCE];    /*分配矩阵*/int NEED[MAXPROCESS][MAXRESOURCE];            /*需求矩阵*/int REQUEST[MAXPROCESS][MAXRESOURCE];        /*进程需要资源数*/bool FINISH[MAXPROCESS];                        /*系统是否有足够的资源分配*/int p[MAXPROCESS];                             /*记录序列*/int m,n;                                    /*m个进程,n个资源*/void Init();bool Safe();void Bank();int main(){Init();Safe();Bank();system("pause");return 0;}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>>ALLOCATION[i][j];NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];if(NEED[i][j]<0){cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;j--;continue;}}}cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){cin>>AVAILABLE[i];}}void Bank()                /*银行家算法*/{int i,cusneed;char again;while(1){cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl;cin>>cusneed;cout<<"请输入进程所请求的各资源的数量"<<endl;for(i=0;i<n;i++){cin>>REQUEST[cusneed][i];}for(i=0;i<n;i++){if(REQUEST[cusneed][i]>NEED[cusneed][i]){cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;continue;}if(REQUEST[cusneed][i]>AVAILABLE[i]){cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;continue;}}for(i=0;i<n;i++){AVAILABLE[i] -= REQUEST[cusneed][i];ALLOCATION[cusneed][i] += REQUEST[cusneed][i];NEED[cusneed][i] -= REQUEST[cusneed][i];}if(Safe()){cout<<"同意分配请求!"<<endl;}else{cout<<"您的请求被拒绝!"<<endl;for(i=0;i<n;i++){AVAILABLE[i] += REQUEST[cusneed][i];ALLOCATION[cusneed][i] -= REQUEST[cusneed][i];NEED[cusneed][i] += REQUEST[cusneed][i];}}for(i=0;i<m;i++){FINISH[i] = false;}cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){continue;}break;}}bool Safe()                                    /*安全性算法*/{int i,j,k,l=0;int Work[MAXRESOURCE];                    /*工作数组*/for(i=0;i<n;i++)Work[i] = AVAILABLE[i];for(i=0;i<m;i++){FINISH[i] = false;}for(i=0;i<m;i++){    if(!FINISH[i]){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]+=ALLOCATION[i][k];}p[l++]=i;i=-1;//每次从最开始寻找一个可以分配的}}}//for(i)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;return false;} 

以以上实例来测试：

请输入进程的数目:5
请输入资源的种类:3
请输入每个进程最多所需的各资源数,按照5x3矩阵输入
7 5 3
3 2 2
9 0 2
2 2 2
4 3 3
请输入每个进程已分配的各资源数,也按照5x3矩阵输入
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2
请输入各个资源现有的数目:
3 3 2
系统是安全的
安全序列:
1-->3-->0-->2-->4
请输入要申请资源的进程号(注:第1个进程号为0,依次类推)
1
请输入进程所请求的各资源的数量
1 0 2
系统是安全的
安全序列:
1-->3-->0-->2-->4
同意分配请求!
您还想再次请求分配吗?是请按y/Y,否请按其它键
y
请输入要申请资源的进程号(注:第1个进程号为0,依次类推)
4
请输入进程所请求的各资源的数量
3 3 0
您输入的请求数超过系统有的资源数!请重新输入!
系统是不安全的
您的请求被拒绝!
您还想再次请求分配吗?是请按y/Y,否请按其它键
y
请输入要申请资源的进程号(注:第1个进程号为0,依次类推)
0
请输入进程所请求的各资源的数量
0 2 0
系统是不安全的
您的请求被拒绝!

注:以上代码均是在Win7+VS2012环境中运行。