GEEKSFORGEEKS
Banker’s Algorithm in Operating
System
The banker’s algorithm is a resource allocation and
deadlock avoidance algorithm that tests for safety by
simulating the allocation for the predetermined
maximum possible amounts of all resources, then
makes an “s-state” check to test for possible activities,
before deciding whether allocation should be allowed to
continue.
Why Banker’s Algorithm is Named
So?
The banker’s algorithm is named so because it is used
in the banking system to check whether a loan can be
sanctioned to a person or not. Suppose there are n
number of account holders in a bank and the total sum
of their money is S. If a person applies for a loan then
the bank first subtracts the loan amount from the total
money that the bank has and if the remaining amount is
greater than S then only the loan is sanctioned. It is
done because if all the account holders come to
withdraw their money then the bank can easily do it.
It also helps the OS to successfully share the resources
between all the processes. It is called the banker’s
algorithm because bankers need a similar algorithm-
they admit loans that collectively exceed the bank’s
funds and then release each borrower’s loan in
installments. The banker’s algorithm uses the notation
of a safe allocation state to ensure that granting a
resource request cannot lead to a deadlock either
immediately or in the future.
In other words, the bank would never allocate its money
in such a way that it can no longer satisfy the needs of
all its customers. The bank would try to be in a safe
state always.
The following Data structures are used to implement
the Banker’s Algorithm:
Let ‘n’ be the number of processes in the system
and ‘m’ be the number of resource types.
Available
It is a 1-d array of size ‘m’ indicating the number of
available resources of each type.
Available[ j ] = k means there are ‘k’ instances of
resource type Rj
Max
It is a 2-d array of size ‘n*m’ that defines the
maximum demand of each process in a system.
Max[ i, j ] = k means process Pi may request at most
‘k’ instances of resource type Rj.
Allocation
It is a 2-d array of size ‘n*m’ that defines the number
of resources of each type currently allocated to each
process.
Allocation[ i, j ] = k means process Pi is currently
allocated ‘k’ instances of resource type Rj
Need
It is a 2-d array of size ‘n*m’ that indicates the
remaining resource need of each process.
Need [ i, j ] = k means process Pi currently needs ‘k’
instances of resource type Rj
Need [ i, j ] = Max [ i, j ] – Allocation [ i, j ]
Allocation specifies the resources currently allocated to
process Pi and Needi specifies the additional resources
that process Pi may still request to complete its task.
Banker’s algorithm consists of a Safety algorithm and a
Resource request algorithm.
Banker’s Algorithm
1. Active:= Running U Blocked;
for k=1…r
New_ request[k]:= Requested_
resources[requesting_ process, k];
2. Simulated_ allocation:= Allocated_ resources;
for k=1…..r //Compute projected allocation state
Simulated_ allocation [requesting _process, k]:=
Simulated_ allocation [requesting _process, k] + New_
request[k];
3. feasible:= true;
for k=1….r // Check whether projected allocation
state is feasible
if Total_ resources[k]< Simulated_ total_ alloc [k]
then feasible:= false;
4. if feasible= true
then // Check whether projected allocation state is a
safe allocation state
while set Active contains a process P1 such that
For all k, Total _resources[k] – Simulated_ total_
alloc[k]>= Max_ need [l ,k]-Simulated_ allocation[l, k]
Delete Pl from Active;
for k=1…..r
Simulated_ total_ alloc[k]:= Simulated_ total_
alloc[k]- Simulated_ allocation[l, k];
5. If set Active is empty
then // Projected allocation state is a safe allocation
state
for k=1….r // Delete the request from pending
requests
Requested_ resources[requesting_ process,
k]:=0;
for k=1….r // Grant the request
Allocated_ resources[requesting_ process, k]:=
Allocated_ resources[requesting_ process, k] + New_
request[k];
Total_ alloc[k]:= Total_ alloc[k] + New_ request[k];
Safety 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, 3, 4….n
2) Find an i such that both
a) Finish[i] = false
b) Needi <= 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 a safe state
Resource-Request Algorithm
Let Requesti be the request array for process Pi.
Requesti [j] = k means process Pi wants k instances of
resource type Rj. When a request for resources is
made by process Pi, the following actions are taken:
1) If Requesti <= Needi
Goto step (2) ; otherwise, raise an error condition,
since the process has exceeded its maximum
claim.
2) If Requesti <= Available
Goto step (3); otherwise, Pi must wait, since the
resources are not available.
3) Have the system pretend to have allocated the
requested resources to process Pi by modifying
the state as
follows:
Available = Available – Requesti
Allocationi = Allocationi + Requesti
Needi = Needi– Requesti
Example:
Considering a system with five processes P0
through P4 and three resources of type A, B, C.
Resource type A has 10 instances, B has 5
instances and type C has 7 instances. Suppose at
time t0 following snapshot of the system has been
taken:
Q.1: What will be the content of the Need
matrix?
Need [i, j] = Max [i, j] – Allocation [i, j]
So, the content of Need Matrix is:
Q.2: Is the system in a safe state? If Yes,
then what is the safe sequence?
Applying the Safety algorithm on the given system,
Q.3: What will happen if
process P1 requests one additional instance
of resource type A and two instances of
resource type C?
We must determine whether this new system state is
safe. To do so, we again execute Safety algorithm on
the above data structures.
Hence the new system state is safe, so we can
immediately grant the request for process P1 .
Code for Banker’s Algorithm
C++ C Java Python3 C# Javascript
// Banker's Algorithm
#include <iostream>
using namespace std;
int main()
{
// P0, P1, P2, P3, P4 are the Process
int n, m, i, j, k;
n = 5; // Number of processes
m = 3; // Number of resources
int alloc[5][3] = { { 0, 1, 0 }, // P0
{ 2, 0, 0 }, // P1
{ 3, 0, 2 }, // P2
{ 2, 1, 1 }, // P3
{ 0, 0, 2 } }; // P4
int max[5][3] = { { 7, 5, 3 }, // P0 //
{ 3, 2, 2 }, // P1
{ 9, 0, 2 }, // P2
{ 2, 2, 2 }, // P3
{ 4, 3, 3 } }; // P4
int avail[3] = { 3, 3, 2 }; // Availabl
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 no
break;
}
}
if(flag==1)
{
cout << "Following is the SAFE Sequen
for (i = 0; i < n - 1; i++)
cout << " P" << ans[i] << " ->";
cout << " P" << ans[n - 1] <<endl;
}
return (0);
}
Output
Following is the SAFE Sequence
P1 -> P3 -> P4 -> P0 -> P2
As the processes enter the system, they must predict
the maximum number of resources needed which is
impractical to determine.
In this algorithm, the number of processes remain
fixed which is not possible in interactive systems.
This algorithm requires that there should be a fixed
number of resources to allocate. If a device breaks
and becomes suddenly unavailable the algorithm
would not work.
Overhead cost incurred by the algorithm can be high
when there are many processes and resources
because it has to be invoked for every processes.
Article Tags : Operating Systems Process Synchronization
Recommended Articles
1. Banker's Algorithm in Operating System
2. Program for Banker's Algorithm | Set 1 (Safety Algorithm)
3. Operating System - Difference Between Distributed
System and Parallel System
4. Deadlock Detection Algorithm in Operating System
5. Sequence Step Algorithm in Operating System
6. Page Buffering Algorithm in Operating System
7. System Protection in Operating System
8. User View Vs Hardware View Vs System View of
Operating System
9. System Programs in Operating System
10. File System Implementation in Operating System
11. Xv6 Operating System -adding a new system call
12. Traps and System Calls in Operating System (OS)
13. Difference between System Software and Operating
System
14. Fork System Call in Operating System
15. Operating System Interview Questions
16. Process Schedulers in Operating System
17. Introduction of Deadlock in Operating System
18. Thread in Operating System
19. Paging in Operating System
20. Segmentation in Operating System
21. File Systems in Operating System
22. Virtual Memory in Operating System
23. Fedora Operating System
24. Real Time Operating System (RTOS)
25. Remote Procedure Call (RPC) in Operating System
Read Full Article
A-143, 9th Floor, Sovereign Corporate
Tower, Sector-136, Noida, Uttar Pradesh -
201305
[email protected]
Company
About Us
Legal
Careers
In Media
Contact Us
Advertise with us
Campus Training Program
Explore
Job-A-Thon Hiring Challenge
Hack-A-Thon
GfG Weekly Contest
Offline Classes (Delhi/NCR)
DSA in JAVA/C++
Master System Design
Master CP
Languages
Python
Java
C++
PHP
GoLang
SQL
R Language
Android Tutorial
DSA Concepts
Data Structures
Arrays
Strings
Linked List
Algorithms
Searching
Sorting
Mathematical
Dynamic Programming
DSA Roadmaps
DSA for Beginners
Basic DSA Coding Problems
DSA Roadmap by Sandeep Jain
DSA with JavaScript
Top 100 DSA Interview Problems
All Cheat Sheets
Web Development
HTML
CSS
JavaScript
Bootstrap
ReactJS
AngularJS
NodeJS
Express.js
Lodash
Computer Science
GATE CS Notes
Operating Systems
Computer Network
Database Management System
Software Engineering
Digital Logic Design
Engineering Maths
Python
Python Programming Examples
Django Tutorial
Python Projects
Python Tkinter
OpenCV Python Tutorial
Python Interview Question
Data Science & ML
Data Science With Python
Data Science For Beginner
Machine Learning Tutorial
Maths For Machine Learning
Pandas Tutorial
NumPy Tutorial
NLP Tutorial
Deep Learning Tutorial
DevOps
Git
AWS
Docker
Kubernetes
Azure
GCP
Competitive Programming
Top DSA for CP
Top 50 Tree Problems
Top 50 Graph Problems
Top 50 Array Problems
Top 50 String Problems
Top 50 DP Problems
Top 15 Websites for CP
System Design
What is System Design
Monolithic and Distributed SD
Scalability in SD
Databases in SD
High Level Design or HLD
Low Level Design or LLD
Top SD Interview Questions
Interview Corner
Company Wise Preparation
Preparation for SDE
Experienced Interviews
Internship Interviews
Competitive Programming
Open In App