Banker's Algorithm Java

In Java, Banker's algorithm is a deadlock avoidance and resource allocation algorithm. This algorithm tests for security by simulating allocation for a predetermined maximum possible amount of all resources. After that, before deciding whether the allocation should be allowed to continue or not, it creates an "s-state" check for testing it to all possible activities.

In order to implement the Banker's algorithm in Java, we use the following data structures:

Suppose we have N processes and M resource types in the system.

Available Data structure

The first data structure which we use is the Available Data Structure. This data structure constructs using a one-dimensional array of size M(Number of available resources). If there are K instances of resource type R_J, it will be denoted as:

Available[ J ] = K

Max Data structure

Another data structure used in Banker's algorithm is Max Data Structure. This data structure constructs using a two-dimensional array of size M*N. In the system, it defines the maximum demand of each process.

If a process P_I request for K instances of resource type R_J, it will be denoted as:

Max[ I, J ] = K

Allocation Data structure

Just like the Available and Max data structure, Allocation Data Structure is a two-dimensional array having a size M*N. It defines the total number of resources allocated to a process.

If a process P_I is currently allocated K instances of resource type R_J, it will be demoted as:

Allocation[ I, J ] = K

Need Data structure

The Need Data Structure is also a two-dimensional array having a size M*N. It defines the total number of remaining resource which a process need.

If a process P_I is currently allocated K instances of resource type R_J, it will be defined as:

Need [ I, J ] = Max[ I, J ] - Allocation [ I, J ]

In simple words, (Allocation)_I define the total number of resources that are currently allocated to a process P_I, and (Need)_I define the total number of remaining resources for which a process P_I is requested for completing its task.

We know that the Banker's algorithm is a combination of the Resource Request Algorithm and Safety Algorithm.

Let's take an overview of both the algorithms, and then we implement both of them to construct Banker's algorithm program in Java.

Resource Request Algorithm

The Resource request algorithm plays an important role in the allocation of resources to a process. This algorithm checks how a system will behave when a process makes each type of resource request in a system as a request matrix.

The request resource algorithm is given below:

1. If Request_I <= Need_I

Jump to step (2)

Else

Print an error message for exceeding its maximum claim.

2. If Request_I <= Available

Jump to step (3);

Else

Print an error message "resources are not available".

3. Allocate the resources to the process and remove the quantity of the resources allocated to a process from the Available and Need like as:

Available = Available - Request_I

Allocation_I = Allocation_I + Request_I

Need_I = Need_I - Request_I

Safety Algorithm

The safety algorithm is used to determine whether our system is in a safe state or not. If the system follows the safe sequence in Banker's algorithm, our system is in a safe state. The safety algorithm is given below:

1. Let the Work and the Finish are the two vectors of length M and N.

Initialize : Work = Available

for 1 to N

Finish [ i ] = false;

2. Find i such that both

Finish [ i ] = false
Need_i <= work

if no such i exists, go to step (4)

3. Work = Work + Allocation_i

Finish[ i ] = true

Go to step(2)

4. If Finish[ i ] = true for all i,

The system is in a safe state.

To get more knowledge about Banker's algorithm, resource request algorithm, and safety algorithm, go through the following link: https://www.javatpoint.com/bankers-algorithm-in-operating-system

Let's implement the code of the Banker's algorithm using the above-discussed resource request and safety algorithm in Java.

BankersAlgoExample.java

// import required classes and packages
import java.util.*; 
import java.io.*; 
import java.util.Scanner;

// create BankersAlgoExample class to implement Banker's algorithm in Java
class BankersAlgoExample
{

	// create findNeedValue() method to calculate the need of each process
	static void findNeedValue(int needArray[][], int maxArray[][], int allocationArray[][], int totalProcess, int totalResources)
	{
		// use nested for loop to calculate Need for each process
		for (int i = 0 ; i < totalProcess ; i++){	// for each process
			for (int j = 0 ; j < totalResources ; j++){	//for each resource
				needArray[i][j] = maxArray[i][j] - allocationArray[i][j];
			}
		}
	}

	// create checkSafeSystem() method to determine whether 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];

		// call findNeedValue() method to calculate needArray
		findNeedValue(needArray, maxArray, allocationArray, totalProcess, totalResources);

		// all the process should be infinished in starting
		boolean []finishProcesses = new boolean[totalProcess];

		// initialize safeSequenceArray that store safe sequenced
		int []safeSequenceArray = new int[totalProcess];

		// initialize workArray as a copy of the available resources
		int []workArray = new int[totalResources];
		
		for (int i = 0; i < totalResources ; i++)	//use for loop to copy each available resource in the workArray
			workArray[i] = availableArray[i];

		// initialize counter variable whose value will be 0 when the system is not in the safe state or when all the processes are not finished.
		int counter = 0;
		
		// use loop to iterate the statements until all the processes are not finished
		while (counter < totalProcess)
		{
			// find infinished process which needs can be satisfied with the current work resource.
			boolean foundSafeSystem = false;
			for (int m = 0; m < totalProcess; m++)
			{
				if (finishProcesses[m] == false)		// when process is not finished
				{
					int j;
					
					//use for loop to check whether the need of each process for all the resources is less than the work
					for (j = 0; j < totalResources; j++)
						if (needArray[m][j] > workArray[j])		//check need of current resource for current process with work
							break;

					// the value of J and totalResources will be equal when all the needs of current process are satisfied
					if (j == totalResources)
					{
						for (int k = 0 ; k < totalResources ; k++)
							workArray[k] += allocationArray[m][k];

						// add current process in the safeSequenceArray
						safeSequenceArray[counter++] = m;

						// make this process finished
						finishProcesses[m] = true;

						foundSafeSystem = true;
					}
				}
			}

			// the system will not be in the safe state when the value of the foundSafeSystem is false
			if (foundSafeSystem == false)
			{
				System.out.print("The system is not in the safe state because lack of resources");
				return false;
			}
		}

		// print the safe sequence
		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;
	}

	// main() method start
	public static void main(String[] args)
	{	
		int numberOfProcesses, numberOfResources;
		
		//create scanner class object to get input from user
		Scanner sc = new Scanner(System.in);
		
		// get total number of resources from the user
		System.out.println("Enter total number of processes");
		numberOfProcesses = sc.nextInt();
		
		// get total number of resources from the user
		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;
		}
		
		int availableArray[] = new int[numberOfResources];
		for( int i = 0; i < numberOfResources; i++){
			System.out.println("Enter the availability of resource"+ i +": ");
			availableArray[i] = sc.nextInt();
		}
		
		int maxArray[][] = new int[numberOfProcesses][numberOfResources];
		for( int i = 0; i < numberOfProcesses; i++){
			for( int j = 0; j < numberOfResources; j++){
				System.out.println("Enter the maximum resource"+ j +" that can be allocated to process"+ i +": ");
				maxArray[i][j] = sc.nextInt();
			}
		}
		
		int allocationArray[][] = new int[numberOfProcesses][numberOfResources];
		for( int i = 0; i < numberOfProcesses; i++){
			for( int j = 0; j < numberOfResources; j++){
				System.out.println("How many instances of resource"+ j +" are allocated to process"+ i +"? ");
				allocationArray[i][j] = sc.nextInt();
			}
		}
		
		//call checkSafeSystem() method to check whether the system is in safe state or not
		checkSafeSystem(processes, availableArray, maxArray, allocationArray, numberOfProcesses, numberOfResources);
	}
}

Output