c语言银行家算法_C语言中的银行家算法-蒲公英云

c语言银行家算法

Here you will get program for banker’s algorithm in C.

在这里，您将获得C语言中银行家算法的程序。

The banker’s algorithm which is also known as avoidance algorithm is a deadlock detection algorithm. It was developed by Edsger Dijkstra. It is designed to check the safe state whenever a resource is requested. It takes analogy of bank, where customer request to withdraw cash. Based on some data the cash is lent to the customer. The banker can’t give more cash than what the customer has requested for, and the total available cash. As this algorithm uses bank analogy so named as banker’s algorithm

银行家算法(也称为回避算法)是一种死锁检测算法。它是由Edsger Dijkstra开发的。它旨在在请求资源时检查安全状态。它以银行为类比，其中客户要求提取现金。根据一些数据，现金贷给了客户。银行家所提供的现金不能超过客户的要求以及可用现金总额。由于此算法使用银行类比，因此被称为银行家算法

Banker’s Algorithm in C

The basic data structures used to implement this algorithm are given below.

下面给出了用于实现该算法的基本数据结构。

Let n be the total number of processes and m be the total number of resource types in the system.

令n为进程总数，m为系统中资源类型的总数。

Available: A vector of length m. It shows number of available resources of each type. If Available[i] = k, then k instances of resource Ri are available.

可用：长度为m的向量。它显示每种类型的可用资源数量。如果Available [i] = k，则资源R i的 k个实例可用。

Max: An n×m matrix that contain maximum demand of each process. If Max[i,j] = k, then process Pi can request maximum k instances of resource type Rj.

最大值：包含每个过程的最大需求的n×m矩阵。如果Max [i，j] = k，则进程P i可以请求最多k个资源类型R j的实例。

Allocation: An n×m matrix that contain number of resources of each type currently allocated to each process. If Allocation[i,j] = k, then Pi is currently allocated k instances of resource type Rj.

分配： n×m矩阵，其中包含当前分配给每个进程的每种类型的资源数量。如果Allocation [i，j] = k，则为P i当前分配资源类型R j的 k个实例。

Need: An n×m matrix that shows the remaining resource need of each process. If Need[i,j] = k, then process Pi may need k more instances of resource type Rj to complete the task.

需求：一个n×m矩阵，显示每个进程的剩余资源需求。如果Need [i，j] = k，则进程P i可能需要k个资源类型R j的更多实例来完成任务。

C语言中银行家算法程序 (Program for Banker’s Algorithm in C)

#include <stdio.h>
int current[5][5], maximum_claim[5][5], available[5];
int allocation[5] = {0, 0, 0, 0, 0};
int maxres[5], running[5], safe = 0;
int counter = 0, i, j, exec, resources, processes, k = 1;
int main()
{
    printf("\nEnter number of processes: ");
        scanf("%d", &processes);
        for (i = 0; i < processes; i++) 
    {
            running[i] = 1;
            counter++;
        }
        printf("\nEnter number of resources: ");
        scanf("%d", &resources);
        printf("\nEnter Claim Vector:");
        for (i = 0; i < resources; i++) 
    { 
            scanf("%d", &maxres[i]);
        }
       printf("\nEnter Allocated Resource Table:\n");
        for (i = 0; i < processes; i++) 
    {
            for(j = 0; j < resources; j++) 
        {
              scanf("%d", &current[i][j]);
            }
        }
        printf("\nEnter Maximum Claim Table:\n");
        for (i = 0; i < processes; i++) 
    {
            for(j = 0; j < resources; j++) 
        {
                    scanf("%d", &maximum_claim[i][j]);
            }
        }
    printf("\nThe Claim Vector is: ");
        for (i = 0; i < resources; i++) 
    {
            printf("\t%d", maxres[i]);
    }
        printf("\nThe Allocated Resource Table:\n");
        for (i = 0; i < processes; i++) 
    {
            for (j = 0; j < resources; j++) 
        {
                    printf("\t%d", current[i][j]);
            }
        printf("\n");
        }
        printf("\nThe Maximum Claim Table:\n");
        for (i = 0; i < processes; i++) 
    {
            for (j = 0; j < resources; j++) 
        {
                printf("\t%d", maximum_claim[i][j]);
            }
            printf("\n");
        }
        for (i = 0; i < processes; i++) 
    {
            for (j = 0; j < resources; j++) 
        {
                    allocation[j] += current[i][j];
            }
        }
        printf("\nAllocated resources:");
        for (i = 0; i < resources; i++) 
    {
            printf("\t%d", allocation[i]);
        }
        for (i = 0; i < resources; i++) 
    {
            available[i] = maxres[i] - allocation[i];
    }
        printf("\nAvailable resources:");
        for (i = 0; i < resources; i++) 
    {
            printf("\t%d", available[i]);
        }
        printf("\n");
        while (counter != 0) 
    {
            safe = 0;
            for (i = 0; i < processes; i++) 
        {
                    if (running[i]) 
            {
                        exec = 1;
                        for (j = 0; j < resources; j++) 
                {
                                if (maximum_claim[i][j] - current[i][j] > available[j]) 
                    {
                                    exec = 0;
                                    break;
                                }
                        }
                        if (exec) 
                {
                                printf("\nProcess%d is executing\n", i + 1);
                                running[i] = 0;
                                counter--;
                                safe = 1;
                                for (j = 0; j < resources; j++) 
                    {
                                    available[j] += current[i][j];
                                }
                            break;
                        }
                    }
            }
            if (!safe) 
        {
                    printf("\nThe processes are in unsafe state.\n");
                    break;
            } 
        else 
        {
                    printf("\nThe process is in safe state");
                    printf("\nAvailable vector:");
                    for (i = 0; i < resources; i++) 
            {
                        printf("\t%d", available[i]);
                    }
                printf("\n");
            }
        }
        return 0;
}