操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现

这篇具有很好参考价值的文章主要介绍了操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

银行家算法是一种资源分配和死锁避免算法,它通过模拟所有资源的预定最大可能数量的分配来测试安全性,然后进行“s状态”检查以测试可能的活动,然后决定是否应该允许继续分配。

为什么银行家算法是这样命名的?

Banker’s algorithm 之所以叫“银行家算法”,是因为它在银行系统中被用来检查贷款是否可以发放给一个人。假设一家银行有n个账户持有人,他们的存款总额是S。如果一个人申请贷款,那么银行首先从银行的存款总额中减去贷款金额,如果余额大于S,那么只有贷款被批准。这样做的原因是,如果所有的账户持有人都来取钱,那么银行就可以很容易地做到这一点。
换句话说,银行绝不会以这样一种方式分配资金。

有效值(Available)

它是一个大小为' m '的一维数组,表示每种类型的可用资源的数量。

Available[j] = k表示资源类型Rj有' k '个实例

最大值(Max)

它是一个大小为' n*m '的二维数组,它定义了系统中每个进程的最大需求。
Max[i, j] = k表示进程Pi最多可以请求资源类型Rj的' k '个实例。

可分配值(Allocation)

它是一个大小为' n*m '的二维数组,定义了当前分配给每个进程的每种类型的资源数量。
分配[i, j] = k表示进程Pi当前被分配资源类型Rj的' k '个实例

需要值 (Need)

它是一个大小为' n*m '的二维数组,表示每个进程所需的剩余资源。
Need [i, j] = k表示流程Pi当前需要资源类型Rj的' k '个实例
需求[i, j] =最大[i, j] -分配[i, j]

Allocationi指定当前分配给Pi处理的资源,Needi指定Pi处理为完成任务可能仍然请求的额外资源。
银行家算法由安全算法和资源请求算法组成

安全算法(Safety Algorithm)

判断系统是否处于安全状态的算法描述如下:

1)设Work和Finish分别为长度为“m”和“n”的向量。
   初始化: Work = Available 
   Finish[i] = false; for i=1, 2, 3, 4….n
2) 找到一个i
     a) Finish[i] = false 
     b) Needi <= Work 
如果不存在I,请执行步骤(4)
3) Work = Work + Allocation[i] 
     Finish[i] = true 
     执行步骤2
4) if Finish [i] = true for all i 
此时系统处于安全状态

 资源请求算法(Resource-Request Algorithm)

设Requesti为进程Pi的请求数组。Requesti [j] = k表示进程Pi需要k个资源类型Rj的实例。当Pi进程请求资源时,会执行以下操作:

1) If Requesti <= Needi 
后到步骤(2);否则,抛出一个错误条件,因为进程已经超过了它的最大请求。
2) If Requesti <= Available 
转到步骤(3);否则,Pi必须等待,因为资源不可用
3) 系统是否通过将状态修改为,假装已将请求的资源分配给处理Pi
如下: 
Available = Available – Requesti 
Allocationi = Allocationi + Requesti 
Needi = Needi– Requesti

例子:
考虑一个有五个进程P0到P4的系统,以及a、B、C类型的三个资源。资源类型a有10个实例,B有5个实例,C有7个实例。假设在t0时刻,系统的以下快照已经被截取:

操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现

 问题1。需求矩阵的内容是什么?
需求[i, j] =最大[i, j] -分配[i, j]
所以,需求矩阵的内容是:

操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现

问题2。系统是否处于安全状态?如果是,那么什么是安全序列?
将Safety算法应用于给定系统

操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现

问题3。如果进程P1请求一个资源类型A的额外实例和两个资源类型C的实例,会发生什么情况? 

操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现

我们必须确定这个新的系统状态是否安全。为此,我们再次对上述数据结构执行Safety算法。 

操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现

 

 因此,新的系统状态是安全的,因此我们可以立即为流程P1授予请求。
银行家算法代码

C语言

// Banker's Algorithm
#include <stdio.h>
int main()
{
    // P0, P1, P2, P3, P4 are the Process names here
 
    int n, m, i, j, k;
    n = 5; // Number of processes
    m = 3; // Number of resources
    int alloc[5][3] = { { 0, 1, 0 }, // P0    // Allocation Matrix
                        { 2, 0, 0 }, // P1
                        { 3, 0, 2 }, // P2
                        { 2, 1, 1 }, // P3
                        { 0, 0, 2 } }; // P4
 
    int max[5][3] = { { 7, 5, 3 }, // P0    // MAX Matrix
                      { 3, 2, 2 }, // P1
                      { 9, 0, 2 }, // P2
                      { 2, 2, 2 }, // P3
                      { 4, 3, 3 } }; // P4
 
    int avail[3] = { 3, 3, 2 }; // Available Resources
 
    int f[n], ans[n], ind = 0;
    for (k = 0; k < n; k++) {
        f[k] = 0;
    }
    int need[n][m];
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++)
            need[i][j] = max[i][j] - alloc[i][j];
    }
    int y = 0;
    for (k = 0; k < 5; k++) {
        for (i = 0; i < n; i++) {
            if (f[i] == 0) {
 
                int flag = 0;
                for (j = 0; j < m; j++) {
                    if (need[i][j] > avail[j]){
                        flag = 1;
                         break;
                    }
                }
 
                if (flag == 0) {
                    ans[ind++] = i;
                    for (y = 0; y < m; y++)
                        avail[y] += alloc[i][y];
                    f[i] = 1;
                }
            }
        }
    }
   
      int flag = 1;
       
      for(int i=0;i<n;i++)
    {
      if(f[i]==0)
      {
        flag=0;
         printf("The following system is not safe");
        break;
      }
    }
     
      if(flag==1)
    {
      printf("Following is the SAFE Sequence\n");
      for (i = 0; i < n - 1; i++)
        printf(" P%d ->", ans[i]);
      printf(" P%d", ans[n - 1]);
    }
     
 
    return (0);
 
    // This code is contributed by Deep Baldha (CandyZack)
}

c++代码

// Banker's Algorithm
#include <iostream>
using namespace std;
 
int main()
{
    // P0, P1, P2, P3, P4 are the Process names here
 
  int n, m, i, j, k;
  n = 5; // Number of processes
  m = 3; // Number of resources
  int alloc[5][3] = { { 0, 1, 0 }, // P0 // Allocation Matrix
                     { 2, 0, 0 }, // P1
                     { 3, 0, 2 }, // P2
                     { 2, 1, 1 }, // P3
                     { 0, 0, 2 } }; // P4
 
  int max[5][3] = { { 7, 5, 3 }, // P0 // MAX Matrix
                   { 3, 2, 2 }, // P1
                   { 9, 0, 2 }, // P2
                   { 2, 2, 2 }, // P3
                   { 4, 3, 3 } }; // P4
 
  int avail[3] = { 3, 3, 2 }; // Available Resources
 
  int f[n], ans[n], ind = 0;
  for (k = 0; k < n; k++) {
    f[k] = 0;
  }
  int need[n][m];
  for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++)
      need[i][j] = max[i][j] - alloc[i][j];
  }
  int y = 0;
  for (k = 0; k < 5; k++) {
    for (i = 0; i < n; i++) {
      if (f[i] == 0) {
 
        int flag = 0;
        for (j = 0; j < m; j++) {
          if (need[i][j] > avail[j]){
            flag = 1;
            break;
          }
        }
 
        if (flag == 0) {
          ans[ind++] = i;
          for (y = 0; y < m; y++)
            avail[y] += alloc[i][y];
          f[i] = 1;
        }
      }
    }
  }
   
  int flag = 1;
   
  // To check if sequence is safe or not
  for(int i = 0;i<n;i++)
  {
        if(f[i]==0)
      {
        flag = 0;
        cout << "The given sequence is not safe";
        break;
      }
  }
 
  if(flag==1)
  {
    cout << "Following is the SAFE Sequence" << endl;
      for (i = 0; i < n - 1; i++)
        cout << " P" << ans[i] << " ->";
      cout << " P" << ans[n - 1] <<endl;
  }
 
    return (0);
}

 Java代码

//Java Program for Bankers Algorithm
public class GfGBankers
{
    int n = 5; // Number of processes
    int m = 3; // Number of resources
    int need[][] = new int[n][m];
    int [][]max;
    int [][]alloc;
    int []avail;
    int safeSequence[] = new int[n];
 
    void initializeValues()
    {
    // P0, P1, P2, P3, P4 are the Process names here
    // Allocation Matrix
    alloc = new int[][] { { 0, 1, 0 }, //P0  
                  { 2, 0, 0 }, //P1
                  { 3, 0, 2 }, //P2
                  { 2, 1, 1 }, //P3
                  { 0, 0, 2 } }; //P4
           
    // MAX Matrix
    max = new int[][] { { 7, 5, 3 }, //P0
             { 3, 2, 2 }, //P1
             { 9, 0, 2 }, //P2
             { 2, 2, 2 }, //P3
             { 4, 3, 3 } }; //P4
     
    // Available Resources 
     avail = new int[] { 3, 3, 2 };
    }
 
    void isSafe()
    {
    int count=0;
     
    //visited array to find the already allocated process
    boolean visited[] = new boolean[n];
    for (int i = 0;i < n; i++)
    {
        visited[i] = false;
    }
         
    //work array to store the copy of available resources
    int work[] = new int[m];   
    for (int i = 0;i < m; i++)
    {
        work[i] = avail[i];
    }
 
    while (count<n)
    {
        boolean flag = false;
        for (int i = 0;i < n; i++)
        {
            if (visited[i] == false)
             {
            int j;
            for (j = 0;j < m; j++)
            {       
                if (need[i][j] > work[j])
                break;
            }
            if (j == m)
            {
               safeSequence[count++]=i;
               visited[i]=true;
               flag=true;
                         
                for (j = 0;j < m; j++)
                {
                work[j] = work[j]+alloc[i][j];
                }
            }
             }
        }
        if (flag == false)
        {
            break;
        }
    }
    if (count < n)
    {
        System.out.println("The System is UnSafe!");
    }
    else
    {
        //System.out.println("The given System is Safe");
        System.out.println("Following is the SAFE Sequence");
                for (int i = 0;i < n; i++)
        {
            System.out.print("P" + safeSequence[i]);
            if (i != n-1)
            System.out.print(" -> ");
        }
    }
    }
     
    void calculateNeed()
    {
    for (int i = 0;i < n; i++)
    {
        for (int j = 0;j < m; j++)
         {
        need[i][j] = max[i][j]-alloc[i][j];
         }
    }       
    }
 
    public static void main(String[] args)
    { 
      int i, j, k;
      GfGBankers gfg = new GfGBankers();
          
      gfg.initializeValues();   
      //Calculate the Need Matrix   
      gfg.calculateNeed();           
             
       // Check whether system is in safe state or not
      gfg.isSafe();       
    }
}

python3 代码

# Driver code:
if __name__=="__main__":
     
    # P0, P1, P2, P3, P4 are the Process names here
    n = 5 # Number of processes
    m = 3 # Number of resources
     
    # Allocation Matrix
    alloc = [[0, 1, 0 ],[ 2, 0, 0 ],
            [3, 0, 2 ],[2, 1, 1] ,[ 0, 0, 2]]
     
    # MAX Matrix
    max = [[7, 5, 3 ],[3, 2, 2 ],
            [ 9, 0, 2 ],[2, 2, 2],[4, 3, 3]]
     
    avail = [3, 3, 2] # Available Resources
     
    f = [0]*n
    ans = [0]*n
    ind = 0
    for k in range(n):
        f[k] = 0
         
    need = [[ 0 for i in range(m)]for i in range(n)]
    for i in range(n):
        for j in range(m):
            need[i][j] = max[i][j] - alloc[i][j]
    y = 0
    for k in range(5):
        for i in range(n):
            if (f[i] == 0):
                flag = 0
                for j in range(m):
                    if (need[i][j] > avail[j]):
                        flag = 1
                        break
                 
                if (flag == 0):
                    ans[ind] = i
                    ind += 1
                    for y in range(m):
                        avail[y] += alloc[i][y]
                    f[i] = 1
                     
    print("Following is the SAFE Sequence")
     
    for i in range(n - 1):
        print(" P", ans[i], " ->", sep="", end="")
    print(" P", ans[n - 1], sep="")
 
# This code is contributed by SHUBHAMSINGH10

 C#代码

// C# Program for Bankers Algorithm
using System;
using System.Collections.Generic;
     
class GFG
{
static int n = 5; // Number of processes
static int m = 3; // Number of resources
int [,]need = new int[n, m];
int [,]max;
int [,]alloc;
int []avail;
int []safeSequence = new int[n];
 
void initializeValues()
{
    // P0, P1, P2, P3, P4 are the Process
    // names here Allocation Matrix
    alloc = new int[,] {{ 0, 1, 0 }, //P0
                        { 2, 0, 0 }, //P1
                        { 3, 0, 2 }, //P2
                        { 2, 1, 1 }, //P3
                        { 0, 0, 2 }};//P4
             
    // MAX Matrix
    max = new int[,] {{ 7, 5, 3 }, //P0
                        { 3, 2, 2 }, //P1
                      { 9, 0, 2 }, //P2
                      { 2, 2, 2 }, //P3
                      { 4, 3, 3 }};//P4
     
    // Available Resources
    avail = new int[] { 3, 3, 2 };
}
 
void isSafe()
{
    int count = 0;
     
    // visited array to find the
    // already allocated process
    Boolean []visited = new Boolean[n];
    for (int i = 0; i < n; i++)
    {
        visited[i] = false;
    }
         
    // work array to store the copy of
    // available resources
    int []work = new int[m];
    for (int i = 0; i < m; i++)
    {
        work[i] = avail[i];
    }
     
    while (count<n)
    {
        Boolean flag = false;
        for (int i = 0; i < n; i++)
        {
            if (visited[i] == false)
            {
                int j;
                for (j = 0; j < m; j++)
                {    
                    if (need[i, j] > work[j])
                    break;
                }
                if (j == m)
                {
                    safeSequence[count++] = i;
                    visited[i] = true;
                    flag = true;
                    for (j = 0; j < m; j++)
                    {
                        work[j] = work[j] + alloc[i, j];
                    }
                }
            }
        }
        if (flag == false)
        {
            break;
        }
    }
    if (count < n)
    {
        Console.WriteLine("The System is UnSafe!");
    }
    else
    {
        //System.out.println("The given System is Safe");
        Console.WriteLine("Following is the SAFE Sequence");
        for (int i = 0; i < n; i++)
        {
            Console.Write("P" + safeSequence[i]);
            if (i != n - 1)
            Console.Write(" -> ");
        }
    }
}
 
void calculateNeed()
{
    for (int i = 0;i < n; i++)
    {
        for (int j = 0;j < m; j++)
        {
            need[i, j] = max[i, j] - alloc[i, j];
        }
    }    
}
 
// Driver Code
public static void Main(String[] args)
{
    GFG gfg = new GFG();
         
    gfg.initializeValues();
     
    // Calculate the Need Matrix
    gfg.calculateNeed();        
             
    // Check whether system is in
    // safe state or not
    gfg.isSafe();    
}
}
 
// This code is contributed by Rajput-Ji

JavaScript代码

<script>
     
  let n, m, i, j, k;
  n = 5; // Number of processes
  m = 3; // Number of resources
  let alloc = [ [ 0, 1, 0 ], // P0 // Allocation Matrix
                [ 2, 0, 0 ], // P1
                [ 3, 0, 2 ], // P2
                [ 2, 1, 1 ], // P3
                [ 0, 0, 2 ] ]; // P4
 
  let max = [ [ 7, 5, 3 ], // P0 // MAX Matrix
              [ 3, 2, 2 ], // P1
              [ 9, 0, 2 ], // P2
              [ 2, 2, 2 ], // P3
              [ 4, 3, 3 ] ]; // P4
 
  let avail = [ 3, 3, 2 ]; // Available Resources
 
  let f = [], ans = [], ind = 0;
  for (k = 0; k < n; k++) {
    f[k] = 0;
  }
  let need = [];
  for (i = 0; i < n; i++) {
      let need1 = [];
    for (j = 0; j < m; j++)
      need1.push(max[i][j] - alloc[i][j]);
    need.push(need1);
  }
  
  let y = 0;
  for (k = 0; k < 5; k++) {
    for (i = 0; i < n; i++) {
      if (f[i] == 0) {
 
        let flag = 0;
        for (j = 0; j < m; j++) {
          if (need[i][j] > avail[j]){
            flag = 1;
            break;
          }
        }
 
        if (flag == 0) {
          ans[ind++] = i;
          for (y = 0; y < m; y++)
            avail[y] += alloc[i][y];
          f[i] = 1;
        }
      }
    }
  }
 
  document.write("Following is the SAFE Sequence" + "<br>");
  for (i = 0; i < n - 1; i++)
    document.write(" P" + ans[i] + " ->");
  document.write( " P" + ans[n - 1] + "<br>");
</script>

 

 输出结果:P1 -> p3 -> p4 -> p0 -> p2




当进程进入系统时,它们必须预测所需资源的最大数量,而确定这一数量并非不切实际。
在该算法中,进程的数量保持固定,这在交互系统中是不可能的。
这种算法要求分配的资源数量是固定的。如果一个设备坏了,突然变得不可用,该算法将无法工作。
当有许多进程和资源时,该算法产生的开销成本可能很高,因为它必须被调用文章来源地址https://www.toymoban.com/news/detail-456591.html

到了这里,关于操作系统银行家算法(JAVA/Python/C#/JavaScript/C/C++)代码实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 操作系统实验 银行家算法C++

    实验目的: 编程实现安全性算法及银行家算法,以帮助深刻理解银行家算法避免死锁的原理。 算法流程图:     实现代码:    验证数据: 运行结果:     说明: 本文章是在原作者的银行家算法文章基础上依据实验课要求修改和完善的,仅供参考,侵权删。  原作者地址

    2024年02月05日
    浏览(37)
  • 【操作系统原理实验】银行家算法模拟实现

    选择一种高级语言如C/C++等,编写一个银行家算法的模拟实现程序。1) 设计相关数据结构;2) 实现系统资源状态查看、资源请求的输入等模块;3) 实现资源的预分配及确认或回滚程序;4) 实现系统状态安全检查程序;5) 组装各模块成一个完整的模拟系统。 (1)设计思想: 1、

    2024年02月01日
    浏览(33)
  • 【操作系统】银行家算法个人出题例题 (含答案)

    1.银行家算法是代表性的避免死锁的算法,在进程调度中具有重要作用。请结合所学知识回答以下问题:(23分——加长版) (1)银行家算法使用的四个必要的数据结构是:可用资源向量Available,____________,分配矩阵Allocation,需求矩阵Need。(1分) (2)以下是银行家算法具体实现

    2024年02月12日
    浏览(27)
  • 操作系统实验二死锁避免之银行家算法的模拟

    死锁  (1)定义  (2)死锁产生的原因  (3)死锁产生的必要条件  (4)死锁的处理策略 银行家算法  (1)核心思想  (2)数据结构  (3)算法描述    (4)  安全性检查算法 银行家算法的模拟 (1)数据结构 (2)完整代码 (3)测试 所谓死锁,是指多个进程因为竞争资

    2024年02月01日
    浏览(51)
  • 银行家算法--申请资源

    问题描述: 输入N个进程(N=100),以及M类资源(M=100),初始化各种资源的总数,T0时刻资源的分配情况。例如: 假定系统中有5个进程{P0,P1,P2,P3,P4}和三类资源{A,B,C},各种资源的数量分别为10、5、7,在T0时刻的资源分配图如下: 输入申请资源的进程以及申请各类资源的数

    2024年02月03日
    浏览(51)
  • 银行家算法

    银行家算法(Banker’s Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础,判断并保证系统的安全运行。 假设客户A、B、C 三人向银行贷款用于建房,分别需要贷款

    2024年02月02日
    浏览(30)
  • 银行家算法(C++实现)

    目录 一、银行家算法概述 二、银行家算法需要的数组结构 三、算法概述 1.安全性算法 2.银行家算法 四、代码实现 五、实验结果验证 银行家算法 (Banker\\\'s Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的

    2024年01月24日
    浏览(23)
  • 银行家算法的实验报告

    一、实验内容 银行家算法是避免死锁的一种重要方法,本实验要求编写和调试一个简单的银行家算法程序。 1.设计进程对各类资源最大申请表示及初值的确定。 2.设定系统提供资源的初始状况。 3.设定每次某个进程对各类资源的申请表示。 4.编制程序,依据银行家算法

    2023年04月26日
    浏览(35)
  • C语言实现银行家算法

    银行家算法 最初是由荷兰计算机科学家艾兹赫尔·迪杰斯特拉(Edsger W. Dijkstra)于1965年提出的。当时他正致力于解决多道程序设计中产生的死锁问题。在多道程序设计中,由于不同进程之间共享有限的系统资源,如内存、I/O设备等,因此存在一个进程等待其他进程释放资源而

    2024年02月05日
    浏览(30)
  • 银行家算法 源码+实验报告(用了自取)

    XI`AN TECHNOLOGICAL UNIVERSITY 课程设计报告 实验课程名称 操作系统—银行家算法     专    业 :计算机科学与技术          班    级 :                姓    名 :                   学    号 :          实验学时 :                     

    2024年02月09日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包