Program for Least Recently Used (LRU) Page Replacement algorithm Last Updated : 15 Sep, 2023 Comments Improve Suggest changes Like Article Like Report Prerequisite: Page Replacement AlgorithmsIn operating systems that use paging for memory management, page replacement algorithm are needed to decide which page needed to be replaced when new page comes in. Whenever a new page is referred and not present in memory, page fault occurs and Operating System replaces one of the existing pages with newly needed page. Different page replacement algorithms suggest different ways to decide which page to replace. The target for all algorithms is to reduce number of page faults.In Least Recently Used (LRU) algorithm is a Greedy algorithm where the page to be replaced is least recently used. The idea is based on locality of reference, the least recently used page is not likely Let say the page reference string 7 0 1 2 0 3 0 4 2 3 0 3 2 . Initially we have 4 page slots empty. Initially all slots are empty, so when 7 0 1 2 are allocated to the empty slots ---> 4 Page faults 0 is already there so ---> 0 Page fault. when 3 came it will take the place of 7 because it is least recently used --->1 Page fault 0 is already in memory so ---> 0 Page fault. 4 will takes place of 1 ---> 1 Page Fault Now for the further page reference string ---> 0 Page fault because they are already available in the memory. Given memory capacity (as number of pages it can hold) and a string representing pages to be referred, write a function to find number of page faults. Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution. Let capacity be the number of pages that memory can hold. Let set be the current set of pages in memory. 1- Start traversing the pages. i) If set holds less pages than capacity. a) Insert page into the set one by one until the size of set reaches capacity or all page requests are processed. b) Simultaneously maintain the recent occurred index of each page in a map called indexes. c) Increment page fault ii) Else If current page is present in set, do nothing. Else a) Find the page in the set that was least recently used. We find it using index array. We basically need to replace the page with minimum index. b) Replace the found page with current page. c) Increment page faults. d) Update index of current page. 2. Return page faults. Below is implementation of above steps. C++ //C++ implementation of above algorithm #include<bits/stdc++.h> using namespace std; // Function to find page faults using indexes int pageFaults(int pages[], int n, int capacity) { // To represent set of current pages. We use // an unordered_set so that we quickly check // if a page is present in set or not unordered_set<int> s; // To store least recently used indexes // of pages. unordered_map<int, int> indexes; // Start from initial page int page_faults = 0; for (int i=0; i<n; i++) { // Check if the set can hold more pages if (s.size() < capacity) { // Insert it into set if not present // already which represents page fault if (s.find(pages[i])==s.end()) { s.insert(pages[i]); // increment page fault page_faults++; } // Store the recently used index of // each page indexes[pages[i]] = i; } // If the set is full then need to perform lru // i.e. remove the least recently used page // and insert the current page else { // Check if current page is not already // present in the set if (s.find(pages[i]) == s.end()) { // Find the least recently used pages // that is present in the set int lru = INT_MAX, val; for (auto it=s.begin(); it!=s.end(); it++) { if (indexes[*it] < lru) { lru = indexes[*it]; val = *it; } } // Remove the indexes page s.erase(val); // insert the current page s.insert(pages[i]); // Increment page faults page_faults++; } // Update the current page index indexes[pages[i]] = i; } } return page_faults; } // Driver code int main() { int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; int n = sizeof(pages)/sizeof(pages[0]); int capacity = 4; cout << pageFaults(pages, n, capacity); return 0; } Java // Java implementation of above algorithm import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; class Test { // Method to find page faults using indexes static int pageFaults(int pages[], int n, int capacity) { // To represent set of current pages. We use // an unordered_set so that we quickly check // if a page is present in set or not HashSet<Integer> s = new HashSet<>(capacity); // To store least recently used indexes // of pages. HashMap<Integer, Integer> indexes = new HashMap<>(); // Start from initial page int page_faults = 0; for (int i=0; i<n; i++) { // Check if the set can hold more pages if (s.size() < capacity) { // Insert it into set if not present // already which represents page fault if (!s.contains(pages[i])) { s.add(pages[i]); // increment page fault page_faults++; } // Store the recently used index of // each page indexes.put(pages[i], i); } // If the set is full then need to perform lru // i.e. remove the least recently used page // and insert the current page else { // Check if current page is not already // present in the set if (!s.contains(pages[i])) { // Find the least recently used pages // that is present in the set int lru = Integer.MAX_VALUE, val=Integer.MIN_VALUE; Iterator<Integer> itr = s.iterator(); while (itr.hasNext()) { int temp = itr.next(); if (indexes.get(temp) < lru) { lru = indexes.get(temp); val = temp; } } // Remove the indexes page s.remove(val); //remove lru from hashmap indexes.remove(val); // insert the current page s.add(pages[i]); // Increment page faults page_faults++; } // Update the current page index indexes.put(pages[i], i); } } return page_faults; } // Driver method public static void main(String args[]) { int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; int capacity = 4; System.out.println(pageFaults(pages, pages.length, capacity)); } } // This code is contributed by Gaurav Miglani Python3 # Python implementation of above algorithm def pageFaults(pages, n, capacity): # To represent set of current pages. We use # an unordered_set so that we quickly check # if a page is present in set or not s = set() # To store least recently used indexes # of pages. indexes = {} # Start from initial page page_faults = 0 for i in range(n): # Check if the set can hold more pages if len(s) < capacity: # Insert it into set if not present # already which represents page fault if pages[i] not in s: s.add(pages[i]) # increment page fault page_faults += 1 # Store the recently used index of # each page indexes[pages[i]] = i # If the set is full then need to perform lru # i.e. remove the least recently used page # and insert the current page else: # Check if current page is not already # present in the set if pages[i] not in s: # Find the least recently used pages # that is present in the set lru = float('inf') for page in s: if indexes[page] < lru: lru = indexes[page] val = page # Remove the indexes page s.remove(val) # insert the current page s.add(pages[i]) # increment page fault page_faults += 1 # Update the current page index indexes[pages[i]] = i return page_faults # Driver code pages = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2] n = len(pages) capacity = 4 print(pageFaults(pages, n, capacity)) # This code is contributed by ishankhandelwals. C# // C# implementation of above algorithm using System; using System.Collections.Generic; class GFG { // Method to find page faults // using indexes static int pageFaults(int []pages, int n, int capacity) { // To represent set of current pages. // We use an unordered_set so that // we quickly check if a page is // present in set or not HashSet<int> s = new HashSet<int>(capacity); // To store least recently used indexes // of pages. Dictionary<int, int> indexes = new Dictionary<int, int>(); // Start from initial page int page_faults = 0; for (int i = 0; i < n; i++) { // Check if the set can hold more pages if (s.Count < capacity) { // Insert it into set if not present // already which represents page fault if (!s.Contains(pages[i])) { s.Add(pages[i]); // increment page fault page_faults++; } // Store the recently used index of // each page if(indexes.ContainsKey(pages[i])) indexes[pages[i]] = i; else indexes.Add(pages[i], i); } // If the set is full then need to // perform lru i.e. remove the least // recently used page and insert // the current page else { // Check if current page is not // already present in the set if (!s.Contains(pages[i])) { // Find the least recently used pages // that is present in the set int lru = int.MaxValue, val = int.MinValue; foreach (int itr in s) { int temp = itr; if (indexes[temp] < lru) { lru = indexes[temp]; val = temp; } } // Remove the indexes page s.Remove(val); //remove lru from hashmap indexes.Remove(val); // insert the current page s.Add(pages[i]); // Increment page faults page_faults++; } // Update the current page index if(indexes.ContainsKey(pages[i])) indexes[pages[i]] = i; else indexes.Add(pages[i], i); } } return page_faults; } // Driver Code public static void Main(String []args) { int []pages = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; int capacity = 4; Console.WriteLine(pageFaults(pages, pages.Length, capacity)); } } // This code is contributed by 29AjayKumar JavaScript <script> // JavaScript implementation of above algorithm // Method to find page faults using indexes function pageFaults(pages,n,capacity) { // To represent set of current pages. We use // an unordered_set so that we quickly check // if a page is present in set or not let s = new Set(); // To store least recently used indexes // of pages. let indexes = new Map(); // Start from initial page let page_faults = 0; for (let i=0; i<n; i++) { // Check if the set can hold more pages if (s.size < capacity) { // Insert it into set if not present // already which represents page fault if (!s.has(pages[i])) { s.add(pages[i]); // increment page fault page_faults++; } // Store the recently used index of // each page indexes.set(pages[i], i); } // If the set is full then need to perform lru // i.e. remove the least recently used page // and insert the current page else { // Check if current page is not already // present in the set if (!s.has(pages[i])) { // Find the least recently used pages // that is present in the set let lru = Number.MAX_VALUE, val=Number.MIN_VALUE; for(let itr of s.values()) { let temp = itr; if (indexes.get(temp) < lru) { lru = indexes.get(temp); val = temp; } } // Remove the indexes page s.delete(val); //remove lru from hashmap indexes.delete(val); // insert the current page s.add(pages[i]); // Increment page faults page_faults++; } // Update the current page index indexes.set(pages[i], i); } } return page_faults; } // Driver method let pages=[7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2]; let capacity = 4; document.write(pageFaults(pages, pages.length, capacity)); // This code is contributed by rag2127 </script> Output: 6Complexity Analysis :Time Complexity : average time complexity of set and map operations is O(1) and the worst-case time complexity is O(n) but O(n) is the dominant term.Space Complexity : O(capacity) which is a constant and depends on the size of the input array and the size of the memory buffer. Another approach: (Without using HashMap) Following are the steps to solve this problem : Using a deque data structure, the program implements the page replacement algorithm.A predetermined number of pages are kept in memory by the algorithm, and they are replaced as new pages are requested.Using an integer array to stimulate page requests, the code keeps track the number of page faults that occur throughout the simulation.The deque data structure, which is built using STL in C++, is used to maintain the pages in memory.The total number of page faults that occurred throughout the simulation is given as output by the code. Below is the implementation of the above approach : C++ // C++ program for page replacement algorithms #include <iostream> #include<bits/stdc++.h> using namespace std; int main() { int capacity = 4; int arr[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; deque<int> q(capacity); int count=0; int page_faults=0; deque<int>::iterator itr; q.clear(); for(int i:arr) { // Insert it into set if not present // already which represents page fault itr = find(q.begin(),q.end(),i); if(!(itr != q.end())) { ++page_faults; // Check if the set can hold equal pages if(q.size() == capacity) { q.erase(q.begin()); q.push_back(i); } else{ q.push_back(i); } } else { // Remove the indexes page q.erase(itr); // insert the current page q.push_back(i); } } cout<<page_faults; } // This code is contributed by Akshit Saxena Java // Java program for page replacement algorithms import java.util.ArrayList; public class LRU { // Driver method public static void main(String[] args) { int capacity = 4; int arr[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; // To represent set of current pages.We use // an Arraylist ArrayList<Integer> s=new ArrayList<>(capacity); int count=0; int page_faults=0; for(int i:arr) { // Insert it into set if not present // already which represents page fault if(!s.contains(i)) { // Check if the set can hold equal pages if(s.size()==capacity) { s.remove(0); s.add(capacity-1,i); } else s.add(count,i); // Increment page faults page_faults++; ++count; } else { // Remove the indexes page s.remove((Object)i); // insert the current page s.add(s.size(),i); } } System.out.println(page_faults); } } Python3 # Python3 program for page replacement algorithm # Driver code capacity = 4 processList = [ 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2] # List of current pages in Main Memory s = [] pageFaults = 0 # pageHits = 0 for i in processList: # If i is not present in currentPages list if i not in s: # Check if the list can hold equal pages if(len(s) == capacity): s.remove(s[0]) s.append(i) else: s.append(i) # Increment Page faults pageFaults +=1 # If page is already there in # currentPages i.e in Main else: # Remove previous index of current page s.remove(i) # Now append it, at last index s.append(i) print("{}".format(pageFaults)) # This code is contributed by mahi_07 C# // C# program for page replacement algorithms using System; using System.Collections.Generic; class LRU { // Driver method public static void Main(String[] args) { int capacity = 4; int []arr = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2}; // To represent set of current pages. // We use an Arraylist List<int> s = new List<int>(capacity); int count = 0; int page_faults = 0; foreach(int i in arr) { // Insert it into set if not present // already which represents page fault if(!s.Contains(i)) { // Check if the set can hold equal pages if(s.Count == capacity) { s.RemoveAt(0); s.Insert(capacity - 1, i); } else s.Insert(count, i); // Increment page faults page_faults++; ++count; } else { // Remove the indexes page s.Remove(i); // insert the current page s.Insert(s.Count, i); } } Console.WriteLine(page_faults); } } // This code is contributed by Rajput-Ji JavaScript let capacity = 4; let arr = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2]; let q = []; let count = 0; let page_faults = 0; let itr; q.length = 0; for (let i of arr) { // Insert it into set if not present // already which represents page fault itr = q.indexOf(i); if (itr == -1) { page_faults++; // Check if the set can hold equal pages if (q.length == capacity) { q.shift(); q.push(i); } else { q.push(i); } } else { // Remove the indexes page q.splice(itr, 1); // insert the current page q.push(i); } } console.log(page_faults); // This code is contributed by ishankhandelwals. Output: 6Complexity Analysis :Time Complexity : O(n), as it performs a constant amount of work for each page request.Space Complexity : O(n+4), where n is the size of the input array and 4 is the size of the memory buffer. Note : We can also find the number of page hits. Just have to maintain a separate count. If the current page is already in the memory then that must be count as Page-hit.We will discuss other Page-replacement Algorithms in further sets. Comment More infoAdvertise with us Next Article Program for Least Recently Used (LRU) Page Replacement algorithm S Sahil Chhabra Improve Article Tags : Greedy Operating Systems GATE CS DSA Practice Tags : Greedy Similar Reads Operating System Tutorial An Operating System(OS) is a software that manages and handles hardware and software resources of a computing device. Responsible for managing and controlling all the activities and sharing of computer resources among different running applications.A low-level Software that includes all the basic fu 4 min read OS BasicsWhat is an Operating System?An Operating System is a System software that manages all the resources of the computing device. Acts as an interface between the software and different parts of the computer or the computer hardware. Manages the overall resources and operations of the computer. Controls and monitors the execution o 9 min read Functions of Operating SystemAn Operating System acts as a communication interface between the user and computer hardware. Its purpose is to provide a platform on which a user can execute programs conveniently and efficiently. The main goal of an operating system is to make the computer environment more convenient to use and to 7 min read Types of Operating SystemsOperating Systems can be categorized according to different criteria like whether an operating system is for mobile devices (examples Android and iOS) or desktop (examples Windows and Linux). Here, we are going to classify based on functionalities an operating system provides.8 Main Operating System 11 min read Need and Functions of Operating SystemsThe fundamental goal of an Operating System is to execute user programs and to make tasks easier. Various application programs along with hardware systems are used to perform this work. Operating System is software that manages and controls the entire set of resources and effectively utilizes every 9 min read Commonly Used Operating SystemThere are various types of Operating Systems used throughout the world and this depends mainly on the type of operations performed. These Operating Systems are manufactured by large multinational companies like Microsoft, Apple, etc. Let's look at the few most commonly used OS in the real world: Win 9 min read Structure of Operating SystemOperating System ServicesAn operating system is software that acts as an intermediary between the user and computer hardware. It is a program with the help of which we are able to run various applications. It is the one program that is running all the time. Every computer must have an operating system to smoothly execute ot 6 min read Introduction of System CallA system call is a programmatic way in which a computer program requests a service from the kernel of the operating system on which it is executed. A system call is a way for programs to interact with the operating system. A computer program makes a system call when it requests the operating system' 11 min read System Programs in Operating SystemSystem Programming can be defined as the act of building Systems Software using System Programming Languages. According to Computer Hierarchy, Hardware comes first then is Operating System, System Programs, and finally Application Programs.In the context of an operating system, system programs are n 5 min read Operating Systems StructuresThe operating system can be implemented with the help of various structures. The structure of the OS depends mainly on how the various standard components of the operating system are interconnected and merge into the kernel. This article discusses a variety of operating system implementation structu 8 min read History of Operating SystemAn operating system is a type of software that acts as an interface between the user and the hardware. It is responsible for handling various critical functions of the computer and utilizing resources very efficiently so the operating system is also known as a resource manager. The operating system 8 min read Booting and Dual Booting of Operating SystemWhen a computer or any other computing device is in a powerless state, its operating system remains stored in secondary storage like a hard disk or SSD. But, when the computer is started, the operating system must be present in the main memory or RAM of the system.What is Booting?When a computer sys 7 min read Types of OSBatch Processing Operating SystemIn the beginning, computers were very large types of machinery that ran from a console table. In all-purpose, card readers or tape drivers were used for input, and punch cards, tape drives, and line printers were used for output. Operators had no direct interface with the system, and job implementat 6 min read Multiprogramming in Operating SystemAs the name suggests, Multiprogramming means more than one program can be active at the same time. Before the operating system concept, only one program was to be loaded at a time and run. These systems were not efficient as the CPU was not used efficiently. For example, in a single-tasking system, 5 min read Time Sharing Operating SystemMultiprogrammed, batched systems provide an environment where various system resources were used effectively, but it did not provide for user interaction with computer systems. Time-sharing is a logical extension of multiprogramming. The CPU performs many tasks by switches that are so frequent that 5 min read What is a Network Operating System?The basic definition of an operating system is that the operating system is the interface between the computer hardware and the user. In daily life, we use the operating system on our devices which provides a good GUI, and many more features. Similarly, a network operating system(NOS) is software th 2 min read Real Time Operating System (RTOS)Real-time operating systems (RTOS) are used in environments where a large number of events, mostly external to the computer system, must be accepted and processed in a short time or within certain deadlines. such applications are industrial control, telephone switching equipment, flight control, and 6 min read Process ManagementIntroduction of Process ManagementProcess Management for a single tasking or batch processing system is easy as only one process is active at a time. With multiple processes (multiprogramming or multitasking) being active, the process management becomes complex as a CPU needs to be efficiently utilized by multiple processes. Multipl 8 min read Process Table and Process Control Block (PCB)While creating a process, the operating system performs several operations. To identify the processes, it assigns a process identification number (PID) to each process. As the operating system supports multi-programming, it needs to keep track of all the processes. For this task, the process control 6 min read Operations on ProcessesProcess operations refer to the actions or activities performed on processes in an operating system. These operations include creating, terminating, suspending, resuming, and communicating between processes. Operations on processes are crucial for managing and controlling the execution of programs i 5 min read Process Schedulers in Operating SystemA process is the instance of a computer program in execution. Scheduling is important in operating systems with multiprogramming as multiple processes might be eligible for running at a time.One of the key responsibilities of an Operating System (OS) is to decide which programs will execute on the C 7 min read Inter Process Communication (IPC)Processes need to communicate with each other in many situations. Inter-Process Communication or IPC is a mechanism that allows processes to communicate. It helps processes synchronize their activities, share information, and avoid conflicts while accessing shared resources.Types of Process Let us f 5 min read Context Switching in Operating SystemContext Switching in an operating system is a critical function that allows the CPU to efficiently manage multiple processes. By saving the state of a currently active process and loading the state of another, the system can handle various tasks simultaneously without losing progress. This switching 4 min read Preemptive and Non-Preemptive SchedulingIn operating systems, scheduling is the method by which processes are given access the CPU. Efficient scheduling is essential for optimal system performance and user experience. There are two primary types of CPU scheduling: preemptive and non-preemptive. Understanding the differences between preemp 5 min read CPU Scheduling in OSCPU Scheduling in Operating SystemsCPU scheduling is a process used by the operating system to decide which task or process gets to use the CPU at a particular time. This is important because a CPU can only handle one task at a time, but there are usually many tasks that need to be processed. The following are different purposes of a 8 min read CPU Scheduling CriteriaCPU scheduling is essential for the system's performance and ensures that processes are executed correctly and on time. Different CPU scheduling algorithms have other properties and the choice of a particular algorithm depends on various factors. Many criteria have been suggested for comparing CPU s 6 min read Multiple-Processor Scheduling in Operating SystemIn multiple-processor scheduling multiple CPUs are available and hence Load Sharing becomes possible. However multiple processor scheduling is more complex as compared to single processor scheduling. In multiple processor scheduling, there are cases when the processors are identical i.e. HOMOGENEOUS 8 min read Thread SchedulingThere is a component in Java that basically decides which thread should execute or get a resource in the operating system. Scheduling of threads involves two boundary scheduling. Scheduling of user-level threads (ULT) to kernel-level threads (KLT) via lightweight process (LWP) by the application dev 7 min read Threads in OSThread in Operating SystemA thread is a single sequence stream within a process. Threads are also called lightweight processes as they possess some of the properties of processes. Each thread belongs to exactly one process.In an operating system that supports multithreading, the process can consist of many threads. But threa 7 min read Threads and its Types in Operating SystemA thread is a single sequence stream within a process. Threads have the same properties as the process so they are called lightweight processes. On single core processor, threads are are rapidly switched giving the illusion that they are executing in parallel. In multi-core systems, threads can exec 8 min read Multithreading in Operating SystemA thread is a path that is followed during a program’s execution. The majority of programs written nowadays run as a single thread. For example, a program is not capable of reading keystrokes while making drawings. These tasks cannot be executed by the program at the same time. This problem can be s 7 min read Process SynchronizationIntroduction of Process SynchronizationProcess Synchronization is used in a computer system to ensure that multiple processes or threads can run concurrently without interfering with each other.The main objective of process synchronization is to ensure that multiple processes access shared resources without interfering with each other an 10 min read Race Condition VulnerabilityRace condition occurs when multiple threads read and write the same variable i.e. they have access to some shared data and they try to change it at the same time. In such a scenario threads are “racing†each other to access/change the data. This is a major security vulnerability.What is Race Conditi 10 min read Critical Section in SynchronizationA critical section is a segment of a program where shared resources, such as memory, files, or ports, are accessed by multiple processes or threads. To prevent issues like data inconsistency and race conditions, synchronization techniques ensure that only one process or thread accesses the critical 8 min read Mutual Exclusion in SynchronizationDuring concurrent execution of processes, processes need to enter the critical section (or the section of the program shared across processes) at times for execution. It might happen that because of the execution of multiple processes at once, the values stored in the critical section become inconsi 6 min read Critical Section Problem SolutionPeterson's Algorithm in Process SynchronizationPeterson's Algorithm is a classic solution to the critical section problem in process synchronization. It ensures mutual exclusion meaning only one process can access the critical section at a time and avoids race conditions. The algorithm uses two shared variables to manage the turn-taking mechanis 15+ min read Semaphores in Process SynchronizationSemaphores are a tool used in operating systems to help manage how different processes (or programs) share resources, like memory or data, without causing conflicts. A semaphore is a special kind of synchronization data that can be used only through specific synchronization primitives. Semaphores ar 15+ min read Semaphores and its typesA semaphore is a tool used in computer science to manage how multiple programs or processes access shared resources, like memory or files, without causing conflicts. Semaphores are compound data types with two fields one is a Non-negative integer S.V(Semaphore Value) and the second is a set of proce 6 min read Producer Consumer Problem using Semaphores | Set 1The Producer-Consumer problem is a classic synchronization issue in operating systems. It involves two types of processes: producers, which generate data, and consumers, which process that data. Both share a common buffer. The challenge is to ensure that the producer doesn't add data to a full buffe 4 min read Readers-Writers Problem | Set 1 (Introduction and Readers Preference Solution)The readers-writer problem in operating systems is about managing access to shared data. It allows multiple readers to read data at the same time without issues but ensures that only one writer can write at a time, and no one can read while writing is happening. This helps prevent data corruption an 7 min read Dining Philosopher Problem Using SemaphoresThe Dining Philosopher Problem states that K philosophers are seated around a circular table with one chopstick between each pair of philosophers. There is one chopstick between each philosopher. A philosopher may eat if he can pick up the two chopsticks adjacent to him. One chopstick may be picked 11 min read Hardware Synchronization Algorithms : Unlock and Lock, Test and Set, SwapProcess Synchronization problems occur when two processes running concurrently share the same data or same variable. The value of that variable may not be updated correctly before its being used by a second process. Such a condition is known as Race Around Condition. There are a software as well as 4 min read Deadlocks & Deadlock Handling MethodsIntroduction of Deadlock in Operating SystemA deadlock is a situation where a set of processes is blocked because each process is holding a resource and waiting for another resource acquired by some other process. In this article, we will discuss deadlock, its necessary conditions, etc. in detail.Deadlock is a situation in computing where two 11 min read Conditions for Deadlock in Operating SystemA deadlock is a situation where a set of processes is blocked because each process is holding a resource and waiting for another resource acquired by some other process. In this article, we will discuss what deadlock is and the necessary conditions required for deadlock.What is Deadlock?Deadlock is 8 min read Banker's Algorithm in Operating SystemBanker's Algorithm is a resource allocation and deadlock avoidance algorithm used in operating systems. It ensures that a system remains in a safe state by carefully allocating resources to processes while avoiding unsafe states that could lead to deadlocks.The Banker's Algorithm is a smart way for 8 min read Wait For Graph Deadlock Detection in Distributed SystemDeadlocks are a fundamental problem in distributed systems. A process may request resources in any order and a process can request resources while holding others. A Deadlock is a situation where a set of processes are blocked as each process in a Distributed system is holding some resources and that 5 min read Handling DeadlocksDeadlock is a situation where a process or a set of processes is blocked, waiting for some other resource that is held by some other waiting process. It is an undesirable state of the system. In other words, Deadlock is a critical situation in computing where a process, or a group of processes, beco 8 min read Deadlock Prevention And AvoidanceDeadlock prevention and avoidance are strategies used in computer systems to ensure that different processes can run smoothly without getting stuck waiting for each other forever. Think of it like a traffic system where cars (processes) must move through intersections (resources) without getting int 5 min read Deadlock Detection And RecoveryDeadlock Detection and Recovery is the mechanism of detecting and resolving deadlocks in an operating system. In operating systems, deadlock recovery is important to keep everything running smoothly. A deadlock occurs when two or more processes are blocked, waiting for each other to release the reso 6 min read Deadlock Ignorance in Operating SystemIn this article we will study in brief about what is Deadlock followed by Deadlock Ignorance in Operating System. What is Deadlock? If each process in the set of processes is waiting for an event that only another process in the set can cause it is actually referred as called Deadlock. In other word 5 min read Recovery from Deadlock in Operating SystemIn today's world of computer systems and multitasking environments, deadlock is an undesirable situation that can bring operations to a halt. When multiple processes compete for exclusive access to resources and end up in a circular waiting pattern, a deadlock occurs. To maintain the smooth function 8 min read Like