JavaAlgorithms/Others/BankersAlgorithm.java

package Others;

/**
 * This file contains an implementation of BANKER'S ALGORITM
 * Wikipedia: https://en.wikipedia.org/wiki/Banker%27s_algorithm
 * 
 * The algorithm for finding out whether or not a system is in a safe state can be described as follows:
 * 1. Let Work and Finish be vectors of length ‘m’ and ‘n’ respectively.
 *      Initialize: Work= Available
 *      Finish [i]=false; for i=1,2,……,n
 * 2. Find an i such that both
 *      a) Finish [i]=false
 *      b) Need_i<=work
 * 
 * if no such i exists goto step (4)
 * 3. Work=Work + Allocation_i
 *      Finish[i]= true
 *      goto step(2)
 * 4. If Finish[i]=true for all i,
 *    then the system is in safe state.
 * 
 * Time Complexity: O(n*n*m) 
 * Space Complexity: O(n*m)
 * where n = number of processes and m = number of resources.
 * 
 * @author AMRITESH ANAND (https://github.com/amritesh19) 
 */

import java.util.Scanner;

public class BankersAlgorithm {

    /**
     * This method finds the need of each process
     */
    static void calculateNeed(int needArray[][], int maxArray[][], int allocationArray[][], int totalProcess, int totalResources)  
    {    
        for (int i = 0 ; i < totalProcess ; i++){      
            for (int j = 0 ; j < totalResources ; j++){    
                needArray[i][j] = maxArray[i][j] - allocationArray[i][j];  
            }  
        }  
    } 

    /**
     * This method find the system is in safe state or not
     * @param processes[] int array of processes (0...n-1), size = n 
     * @param availableArray[] int array of number of instances of each resource, size = m 
     * @param maxArray[][] int matrix(2-D array) of maximum demand of each process in a system, size = n*m
     * @param allocationArray[][] int matrix(2-D array) of  the number of resources of each type currently allocated to each process,  size = n*m
     * @param totalProcess number of total processes, n
     * @param totalResources number of total resources, m
     * 
     * @return boolean if the system is in safe state or not
     */
    static boolean checkSafeSystem(int processes[], int availableArray[], int maxArray[][], int allocationArray[][], int totalProcess, int totalResources)  
    {  
        int [][]needArray = new int[totalProcess][totalResources];  
   
        calculateNeed(needArray, maxArray, allocationArray, totalProcess, totalResources);  
  
        boolean []finishProcesses = new boolean[totalProcess];  
  
        int []safeSequenceArray = new int[totalProcess];  
   
        int []workArray = new int[totalResources];  
          
        for (int i = 0; i < totalResources ; i++)      
            workArray[i] = availableArray[i];  
   
        int count = 0;  
        
        // While all processes are not finished or system is not in safe state.
        while (count < totalProcess)  
        {  
            boolean foundSafeSystem = false;  
            for (int m = 0; m < totalProcess; m++)  
            {  
                if (finishProcesses[m] == false)       
                {  
                    int j;  
                       
                    for (j = 0; j < totalResources; j++)  
                        if (needArray[m][j] > workArray[j])      
                            break;  
   
                    if (j == totalResources)  
                    {  
                        for (int k = 0 ; k < totalResources ; k++)  
                            workArray[k] += allocationArray[m][k];  
   
                        safeSequenceArray[count++] = m;  
  
                        finishProcesses[m] = true;  
  
                        foundSafeSystem = true;  
                    }  
                }  
            }  
            
            // If we could not find a next process in safe sequence.
            if (foundSafeSystem == false)  
            {  
                System.out.print("The system is not in the safe state because lack of resources");  
                return false;  
            }  
        }  
    
        System.out.print("The system is in safe sequence and the sequence is as follows: ");  
        for (int i = 0; i < totalProcess ; i++)  
            System.out.print("P"+safeSequenceArray[i] + " ");  
  
        return true;  
    }  

    /**
     * This is main method of Banker's Algorithm 
     */
    public static void main(String[] args){
        int numberOfProcesses, numberOfResources;

        Scanner sc = new Scanner(System.in); 
        
        System.out.println("Enter total number of processes");  
        numberOfProcesses = sc.nextInt();

        System.out.println("Enter total number of resources");  
        numberOfResources = sc.nextInt(); 

        int processes[] = new int[numberOfProcesses];  
        for(int i = 0; i < numberOfProcesses; i++){  
            processes[i] = i;  
        }

        System.out.println("--Enter the availability of--");

        int availableArray[] = new int[numberOfResources];  
        for( int i = 0; i < numberOfResources; i++){  
            System.out.println("resource "+ i +": ");  
            availableArray[i] = sc.nextInt();  
        }  

        System.out.println("--Enter the maximum matrix--");

        int maxArray[][] = new int[numberOfProcesses][numberOfResources];  
        for( int i = 0; i < numberOfProcesses; i++){  
            System.out.println("For process "+ i + ": ");
            for( int j = 0; j < numberOfResources; j++){  
                System.out.println("Enter the maximum instances of resource "+ j);  
                maxArray[i][j] = sc.nextInt();  
            }  
        } 

        System.out.println("--Enter the allocation matrix--");

        int allocationArray[][] = new int[numberOfProcesses][numberOfResources];  
        for( int i = 0; i < numberOfProcesses; i++){  
            System.out.println("For process "+ i + ": ");
            for( int j = 0; j < numberOfResources; j++){  
                System.out.println("Allocated instances of resource "+ j );  
                allocationArray[i][j] = sc.nextInt();  
            }  
        } 

        checkSafeSystem(processes, availableArray, maxArray, allocationArray, numberOfProcesses, numberOfResources);  

        sc.close();
    }
}

/*
    Example: 
    n = 5
    m = 3

    Process     Allocation      Max       Available
                0   1   2    0   1   2    0   1   2

        0       0   1   0    7   5   3    3   3   2
        1       2   0   0    3   2   2 
        2       3   0   2    9   0   2
        3       2   1   1    2   2   2
        4       0   0   2    4   3   3

    Result: The system is in safe sequence and the sequence is as follows: P1, P3, P4, P0, P2 
 */