Linux操作系统 --避免死锁（银行家算法）实验

小树呀1820

已于 2024-01-16 13:27:46 修改

阅读量1.7k

点赞数 25

文章标签： linux 算法

于 2024-01-16 13:13:44 首次发布

本文链接：https://blog.csdn.net/2201_75758580/article/details/135622020

版权

一、实验目的

加深了解有关资源申请，避免死锁等概念。
体会和了解死锁和避免死锁的具体实施方法。
了解死锁的相关知识。
掌握银行家算法、系统安全性检查算法。

二、实验内容

银行家算法（Banker’s Algorithm）是一个避免进程死锁的著名算法。通过银行家算法，我们可以有效地避免死锁发生的情况。请根据银行家算法完成下列题目。

设系统中有3种类型的资源（A,B,C）和5个进程P1、P2、P3、P4、P5，其中Available=（2,3,3）。在T0时刻系统状态见下表（T0时刻系统状态表）所示。

T0时刻系统状态表

	资源需求量	已分配资源数量
	A B C	A B C
P1	3 4 7	2 1 2
P2	1 3 4	4 0 2
P3	0 0 3	3 0 5
P4	2 2 1	2 0 4
P5	1 1 0	3 1 4

请求序列如下：
a：进程P2请求资源（0，3，4）
b：进程P4请求资源（1，0，1）
c：进程P1请求资源（2，0，1）
d：进程P3请求资源（0，0，2）

试问：系统能否将进程请求的资源分配给它？

任务1：认真阅读程序，将程序执行的流程描述出来。

任务2：修改程序，要求如果资源分配成功，将安全序列输出。

三、主要操作代码整理与实验结果展示

（一）源程序（实验步骤/实验过程/算法）

#include<iostream>

#include<string>

using namespace std;

#define n 5

#define m 3

int available[m] = { 2,3,3 }, alloc[n][m], need[n][m], request[n][m];

void init()

{

             alloc[0][0] = 2;  alloc[0][1] = 1;  alloc[0][2] = 2;

             alloc[1][0] = 4;  alloc[1][1] = 0;  alloc[1][2] = 2;

             alloc[2][0] = 3;  alloc[2][1] = 0;  alloc[2][2] = 5;

             alloc[3][0] = 2;  alloc[3][1] = 0;  alloc[3][2] = 4;

             alloc[4][0] = 3;  alloc[4][1] = 1;  alloc[4][2] = 4;



             need[0][0] = 3;  need[0][1] = 4;  need[0][2] = 7;

             need[1][0] = 1;  need[1][1] = 3;  need[1][2] = 4;

             need[2][0] = 0;  need[2][1] = 0;  need[2][2] = 3;

             need[3][0] = 2;  need[3][1] = 2;  need[3][2] = 1;

             need[4][0] = 1;  need[4][1] = 1;  need[4][2] = 0;



             request[0][0] = 2;  request[0][1] = 0;  request[0][2] = 1;

             request[1][0] = 0;  request[1][1] = 3;  request[1][2] = 4;

             request[2][0] = 0;  request[2][1] = 0;  request[2][2] = 2;

             request[3][0] = 1;  request[3][1] = 0;  request[3][2] = 1;

            

}

void display()

{ int i,j,k;

             cout << "资源 可分配" << endl;

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

             {

               cout << (char)('A' + i) << "      " << available[i] << endl;

             }

             cout << endl;

             cout << "进程 资源 已分配 需求"<<endl;

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

             {



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

               {

                      cout << j+1<< "     " <<(char)('A' + k)<< "     " << alloc[j][k] << "     " << need[j][k] << endl;

               }

             }

             cout << endl;

}

bool judge()

{

             int i, j, tag = n;

             bool non;

             int work[m], finish[n];

             for (i = 0; i<m; i++) work[i] = available[i];

             for (i = 0; i<n; i++) finish[i] = 0;            

             while (tag--)

             {

               for (i = 0; i<n; i++)   

               {

                      if (finish[i] == 0)

                      {

                             non = true;

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

                             {

                                    if (need[i][j] > work[j]) non = false;

                             }

                             if(non)

                             {

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

                                    {

                                           work[j] = work[j] + alloc[i][j];

                                           finish[i] = 1;

                                    }

                             }

                      }

               }

             }

             non = true;

             for (i = 0; i < n; i++)

             {

               if (finish[i] != 1) non = false;

             }

             if (non) return 1;

             else return 0;

}

void deal(int k)

{

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

             {

               if (request[k][j] > need[k][j])

               {

            

                      cout << " 非法！！！" << endl;

                      return;

               }

             }

             for (int w = 0; w< m; w++)

             {

               if (request[k][w] > available[w])

               {

            

                      cout << " 阻塞！！！" << endl;

                      return;

               }

             }

             for (int p = 0; p < m; p++)  //试探性分配

             {

               available[p] -= request[k][p];

               alloc[k][p] += request[k][p];

               need[k][p] -= request[k][p];

             }

             if (judge())

             {

    

               cout << " 资源分配成功！！！" << endl << endl;

               display();

             }

             else

             {

            

               cout << " 资源分配后系统处于不安全状态！！！" << endl;

               for (int j = 0; j < m; j++)  //试探性分配还原

               {

                      available[j] += request[k][j];

                      alloc[k][j] -= request[k][j];

                      need[k][j] += request[k][j];

               }

             }

             cout << endl;

}

int main()

{

             init();

             display();

             cout << "a: 进程p2请求资源（0，3，4）  " ;

             deal(1);

             cout << "b: 进程p4请求资源（1，0，1）  " ;

             deal(3); 

             cout << "c: 进程p1请求资源（2，0，1）  " ;

             deal(0);

             cout << "d: 进程p3请求资源（0，0，2）  " ;

             deal(2);

             return 0;

}