📝 Banker's Algorithm in Deadlock Avoidance (49 MCQs)

📖 From Operating System • 7. Deadlocks • 49 questions available

←Previous Topic:Hold and Wait Deadlock Prevention📝 Banker's Algorithm in Deadlock AvoidanceNext Topic →

What is Banker's Algorithm in Deadlock Avoidance?

Definition:
Banker's Algorithm is a safety-check procedure for multiple-instance resources that simulates resource allocation to verify if a safe sequence exists.

Example:
Given Available vector $\vec{A}$ , Max matrix $M$ , and Allocation matrix $C$ , the algorithm iteratively finds process $P_i$ where $Need_i \leq Work$ and marks it finished.

Reason:
It provides a general solution for multi-instance resource avoidance, though its $O(n^2 m)$ complexity makes it suitable primarily for batch or small-scale interactive systems.

Easy

Medium

Hard

📝 All Banker's Algorithm in Deadlock Avoidance MCQs

Q1. Why is the Banker's Algorithm named as such?

A.It was developed by a banker.

B.It mimics a bank ensuring it never allocates cash such that it cannot satisfy all customers. ✅

C.It uses financial interest rates to prioritize processes.

D.It requires processes to deposit resources before borrowing.

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: The algorithm is named after the analogy of a bank managing its cash reserves. The bank must ensure that it always retains enough cash to satisfy the withdrawal needs of all its customers, similar to how the OS ensures enough resources are available to satisfy all processes' maximum demands.

Q2. For which type of resource system is the Banker's Algorithm primarily designed?

A.Systems with only one instance of each resource type.

B.Systems with multiple instances of each resource type. ✅

C.Systems with no resource sharing.

D.Systems with dynamic resource creation only.

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: The text explicitly states that the resource-allocation-graph algorithm is not applicable to systems with multiple instances. The Banker's Algorithm is described as the applicable deadlock avoidance algorithm for such systems.

Q3. What must a process declare when it first enters the system?

A.Its minimum resource requirement.

B.Its maximum number of instances of each resource type it may need. ✅

C.Its current resource holdings.

D.Its priority level.

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: Upon entering the system, a process must declare the maximum number of instances of each resource type it might need. This declaration is crucial for the algorithm to determine safety and cannot exceed the total number of resources in the system.

Q4. Which data structure represents the number of available instances of each resource type?

A.Max

B.Allocation

C.Need

D.Available ✅

💡 Difficulty: easy | ✅ Correct: D

📖 Explanation: The `Available` vector, of length m (number of resource types), indicates the number of available resources of each type. If `Available[j] = k`, then k instances of resource type Rj are currently free.

Q5. How is the `Need` matrix calculated?

A.Need[i][j] = Max[i][j] + Allocation[i][j]

B.Need[i][j] = Max[i][j] - Allocation[i][j] ✅

C.Need[i][j] = Available[j] - Allocation[i][j]

D.Need[i][j] = Max[i][j] * Allocation[i][j]

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: The `Need` matrix indicates the remaining resource need for each process. It is calculated by subtracting the currently allocated resources (`Allocation`) from the maximum declared demand (`Max`) for each process and resource type.

Q6. What does the condition `Need[i][j] = k` signify?

A.Process Pi has allocated k instances of Rj.

B.Process Pi may request at most k more instances of Rj. ✅

C.There are k instances of Rj available.

D.Process Pi has finished using Rj.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The `Need` matrix specifies the additional resources a process may still request to complete its task. If `Need[i][j] = k`, it means process Pi might still need up to k more instances of resource type Rj.

Q7. In the vector notation used, what does `X ≤ Y` mean?

A.X is strictly less than Y.

B.X[i] ≤ Y[i] for all i. ✅

C.The sum of X is less than the sum of Y.

D.X and Y are equal.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The notation `X ≤ Y` for vectors of length n is defined element-wise. It holds true if and only if every component `X[i]` is less than or equal to the corresponding component `Y[i]` for all indices i from 1 to n.

Q8. What is the initial value of the `Work` vector in the Safety Algorithm?

A.Zero vector

B.Available vector ✅

C.Max vector

D.Allocation vector

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The Safety Algorithm begins by initializing the `Work` vector to be equal to the `Available` vector. `Work` represents the resources currently available for allocation during the simulation of the safety check.

Q9. What is the initial state of the `Finish` array in the Safety Algorithm?

A.All true

B.All false ✅

C.True for processes with no needs

D.False for processes with no needs

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The `Finish` array, of length n (number of processes), is initialized to `false` for all processes. It tracks whether a process can successfully complete its execution in the simulated safe sequence.

Q10. In the Safety Algorithm, what condition must be met to select a process Pi for simulation?

A.Finish[i] == true and Need_i ≤ Work

B.Finish[i] == false and Need_i > Work

C.Finish[i] == false and Need_i ≤ Work ✅

D.Finish[i] == true and Need_i ≥ Work

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: The algorithm searches for an index `i` such that the process has not yet been marked as finished (`Finish[i] == false`) and its remaining needs can be satisfied by the currently available work resources (`Need_i ≤ Work`).

Q11. When a process Pi is selected in the Safety Algorithm, how is the `Work` vector updated?

A.Work = Work - Need_i

B.Work = Work + Allocation_i ✅

C.Work = Work + Need_i

D.Work = Work - Allocation_i

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: Once a process Pi is found that can complete (its needs are met by `Work`), it is assumed to finish and release all its currently held resources. Therefore, its `Allocation_i` is added back to `Work` (`Work = Work + Allocation_i`).

Q12. If the Safety Algorithm completes and `Finish[i] == true` for all i, the system is in what state?

A.Unsafe

B.Deadlocked

C.Safe ✅

D.Unstable

💡 Difficulty: easy | ✅ Correct: C

📖 Explanation: If the algorithm can find a sequence where all processes can finish (indicated by `Finish[i]` being true for all i), it proves that the current state is safe. A safe state means there exists at least one sequence of process executions that avoids deadlock.

Q13. What is the time complexity of the Safety Algorithm?

A.O(n)

B.O(m)

C.O(m × n²) ✅

D.O(n³)

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: The text states that the Safety Algorithm may require an order of m × n² operations to determine whether a state is safe, where m is the number of resource types and n is the number of processes.

Q14. In the Resource-Request Algorithm, what is the first check performed when process Pi makes a request?

A.If Request_i ≤ Available

B.If Request_i ≤ Need_i ✅

C.If the system is safe

D.If Finish[i] is false

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The first step is to verify if the request exceeds the process's declared maximum need. If `Request_i` is not less than or equal to `Need_i`, an error condition is raised because the process has exceeded its maximum claim.

Q15. If `Request_i > Available`, what happens to process Pi?

A.The request is granted immediately.

B.An error is raised.

C.Pi must wait until resources become available. ✅

D.The system enters an unsafe state.

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: If the requested resources are not currently available (`Request_i` is not ≤ `Available`), the process Pi cannot be granted the resources immediately and must wait until enough resources are released by other processes.

Q16. What does the system do in Step 3 of the Resource-Request Algorithm?

A.Permanently allocates the resources.

B.Restores the previous state.

C.Pretends to allocate the resources and updates data structures temporarily. ✅

D.Terminates the process.

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: Before committing, the system simulates the allocation. It temporarily modifies `Available`, `Allocation_i`, and `Need_i` as if the request were granted. This 'pretend' state is then tested for safety.

Q17. If the new state after pretending to allocate resources is found to be unsafe, what action is taken?

A.The allocation is committed.

B.The process is terminated.

C.The old resource-allocation state is restored, and Pi waits. ✅

D.The system ignores the unsafe state.

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: Safety is paramount. If the simulated allocation leads to an unsafe state, the transaction is aborted. The system restores the original values of `Available`, `Allocation_i`, and `Need_i`, and process Pi must wait for its request.

Q18. If the new state after pretending to allocate resources is found to be safe, what action is taken?

A.The allocation is committed, and Pi receives the resources. ✅

B.The state is restored, and Pi waits.

C.The system shuts down.

D.The request is denied permanently.

💡 Difficulty: medium | ✅ Correct: A

📖 Explanation: If the safety algorithm confirms that the new state is safe, the tentative changes become permanent. The resources are officially allocated to process Pi, and it can proceed.

Q19. Consider a system with 3 resource types. If Available = (3, 3, 2) and Request = (1, 0, 2), is the request initially available?

A.No, because 1 > 3

B.Yes, because (1, 0, 2) ≤ (3, 3, 2) ✅

C.No, because 2 > 2

D.Yes, because 1 < 3

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: To check availability, we compare the request vector element-wise with the available vector. Since 1≤3, 0≤3, and 2≤2, the condition `Request ≤ Available` holds true, meaning the resources are currently available.

Q20. In the illustrative example, why was P1's request for (1, 0, 2) granted?

A.Because P1 had the highest priority.

B.Because the resources were available and the resulting state was safe. ✅

C.Because P1 had no other needs.

D.Because the system was already deadlocked.

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: The request was granted because two conditions were met: first, the resources were available (`Request ≤ Available`), and second, after simulating the allocation, the Safety Algorithm found a valid safe sequence (<P1, P3, P4, P0, P2>), confirming the new state was safe.

Q21. In the illustrative example, why was P0's request for (0, 2, 0) denied even though resources were available?

A.Because P0 exceeded its maximum claim.

B.Because the resources were not available.

C.Because the resulting state would be unsafe. ✅

D.Because P0 was already finished.

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: The text notes that while resources might be physically available, the request was denied because granting it would lead to an unsafe state. The Safety Algorithm would have failed to find a safe sequence for the new state, so the request was rejected to prevent potential deadlock.

Q22. What is the primary disadvantage of the Banker's Algorithm compared to the resource-allocation graph scheme?

A.It cannot handle multiple resource instances.

B.It is less efficient. ✅

C.It does not use a priori claims.

D.It cannot detect deadlocks.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The text explicitly mentions that the Banker's Algorithm is less efficient than the resource-allocation graph scheme." This is due to the overhead of running the Safety Algorithm (O(m × n²)) for every resource request."

Q23. Can a process change its maximum claim after it has started executing?

A.Yes, at any time.

B.No, the maximum claim is fixed upon entry. ✅

C.Only if the system is safe.

D.Only if it releases all resources.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The algorithm requires the maximum number of instances to be declared when the process enters the system. This static declaration is fundamental to the safety calculations. Changing it dynamically would invalidate the existing safety guarantees unless complex re-evaluation occurs, which is not part of the standard algorithm described.

Q24. If `Need_i` is a zero vector for a process Pi, what does this imply?

A.Pi has not requested any resources.

B.Pi has reached its maximum allocation and needs no more resources to complete. ✅

C.Pi is deadlocked.

D.Pi has released all resources.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: `Need_i = Max_i - Allocation_i`. If `Need_i` is zero, it means `Allocation_i` equals `Max_i`. The process has all the resources it declared it might need and therefore requires no additional resources to complete its task.

Q25. What happens to the `Available` vector when a request `Request_i` is tentatively granted?

A.Available = Available + Request_i

B.Available = Available - Request_i ✅

C.Available remains unchanged

D.Available = Request_i

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: When resources are allocated to a process, they are no longer free. Therefore, the `Available` vector is updated by subtracting the requested resources: `Available = Available - Request_i`.

Q26. What happens to the `Allocation_i` vector when a request `Request_i` is tentatively granted?

A.Allocation_i = Allocation_i - Request_i

B.Allocation_i = Allocation_i + Request_i ✅

C.Allocation_i remains unchanged

D.Allocation_i = Request_i

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The process receives the requested resources, so its current allocation increases. The update is `Allocation_i = Allocation_i + Request_i`.

Q27. What happens to the `Need_i` vector when a request `Request_i` is tentatively granted?

A.Need_i = Need_i + Request_i

B.Need_i = Need_i - Request_i ✅

C.Need_i remains unchanged

D.Need_i = Available - Request_i

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: Since the process has received some of the resources it needed, its remaining need decreases. The update is `Need_i = Need_i - Request_i`.

Q28. Which of the following is NOT a data structure used in the Banker's Algorithm?

A.Available

B.Max

C.Priority ✅

D.Need

💡 Difficulty: easy | ✅ Correct: C

📖 Explanation: The four key data structures are `Available`, `Max`, `Allocation`, and `Need`. Priority is not part of the standard Banker's Algorithm data structures for deadlock avoidance.

Q29. If a system is in an unsafe state, does it mean a deadlock has already occurred?

A.Yes, always.

B.No, it means deadlock is possible but not certain. ✅

C.No, it means the system is safe.

D.Yes, but only if there are multiple instances.

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: An unsafe state means the system *cannot guarantee* that it can avoid deadlock. It implies that there is at least one sequence of future requests that could lead to deadlock. However, deadlock has not necessarily occurred yet; it might still be avoided if processes release resources or don't make the worst-case requests.

Q30. Why is the condition `Request_i ≤ Need_i` critical?

A.To ensure resources are available.

B.To prevent a process from exceeding its declared maximum demand. ✅

C.To calculate the safe sequence.

D.To update the Available vector.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: This check ensures that a process does not ask for more resources than it originally declared it would ever need. Allowing a process to exceed its maximum claim would break the assumptions of the safety algorithm, making deadlock avoidance impossible.

Q31. In the Safety Algorithm, if no index `i` is found such that `Finish[i] == false` and `Need_i ≤ Work`, what is the next step?

A.Restart the algorithm.

B.Declare the system safe.

C.Go to step 4 to check if all processes are finished. ✅

D.Terminate all processes.

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: If the search in Step 2 fails to find a runnable process, the algorithm proceeds to Step 4. In Step 4, it checks the `Finish` array. If all entries are true, the system is safe. If any are false, the system is unsafe.

Q32. What does the vector `Allocation_i` represent?

A.The maximum resources Pi can ever need.

B.The resources Pi currently holds. ✅

C.The resources Pi still needs.

D.The resources available in the system.

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: The row `Allocation_i` in the `Allocation` matrix specifies the number of instances of each resource type that are currently allocated to process Pi.

Q33. What does the vector `Max_i` represent?

A.The resources Pi currently holds.

B.The resources Pi still needs.

C.The maximum number of instances of each resource type Pi may request. ✅

D.The available resources.

💡 Difficulty: easy | ✅ Correct: C

📖 Explanation: The row `Max_i` in the `Max` matrix defines the maximum demand of process Pi. It indicates the upper limit of resources Pi might request during its lifetime.

Q34. If `Available` is (2, 1, 0) and `Request` is (1, 1, 1), can the request be granted based on availability alone?

A.Yes

B.No ✅

C.Maybe

D.Depends on Need

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: Comparing element-wise: 1≤2 (True), 1≤1 (True), but 1≤0 (False). Since the third component of the request exceeds the available amount, `Request ≤ Available` is false. The resources are not available, so the request cannot be granted immediately.

Q35. Which scenario best illustrates the concept of a 'safe state'?

A.All processes are waiting for resources.

B.The system can allocate resources to all processes in some order without deadlocking. ✅

C.One process holds all resources.

D.The system has no available resources.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: A safe state is defined by the existence of at least one safe sequence. This means the system can find an order to execute processes such that each can obtain its maximum needed resources, finish, and release them, allowing others to proceed, thus avoiding deadlock.

Q36. What is the relationship between `Max`, `Allocation`, and `Need`?

A.Max = Allocation + Need ✅

B.Max = Allocation - Need

C.Need = Max + Allocation

D.Allocation = Max + Need

💡 Difficulty: medium | ✅ Correct: A

📖 Explanation: By definition, `Need[i][j] = Max[i][j] - Allocation[i][j]`. Rearranging this equation gives `Max[i][j] = Allocation[i][j] + Need[i][j]`. The maximum demand is the sum of what is currently held and what is still needed.

Q37. If a process Pi has `Need_i` = (0, 0, 0), what will happen to it in the Safety Algorithm?

A.It will be skipped.

B.It will be selected first if `Finish[i]` is false, as (0,0,0) ≤ Work is always true. ✅

C.It will cause an error.

D.It will be marked as unsafe.

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: If `Need_i` is zero, the condition `Need_i ≤ Work` is always true regardless of the `Work` vector (assuming non-negative resources). Therefore, if `Finish[i]` is false, Pi will be selected, its `Allocation` added to `Work`, and it will be marked as finished. This simulates the process completing and releasing resources.

Q38. Why is the Banker's Algorithm considered conservative?

A.It grants all requests immediately.

B.It denies requests that might lead to unsafe states, even if resources are free. ✅

C.It uses very little memory.

D.It allows processes to exceed their maximum claims.

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: The algorithm prioritizes safety over immediate gratification. It may deny a request even if the resources are physically available (`Request ≤ Available`) if granting it would transition the system into an unsafe state. This conservatism ensures deadlock freedom but can reduce resource utilization and concurrency.

Q39. What is the purpose of the `Finish` array in the Safety Algorithm?

A.To store the final allocation.

B.To track which processes have been simulated to completion. ✅

C.To count the number of resources.

D.To store the maximum needs.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The `Finish` array is a boolean vector used to mark processes that have been successfully simulated to completion in the safe sequence search. If `Finish[i]` becomes true, it means Pi can get its needed resources, finish, and release its held resources in the simulated scenario.

Q40. If the system is in a safe state, can deadlock occur?

A.Yes, immediately.

B.No, not if the system continues to operate within the safe state guidelines. ✅

C.Yes, if a new process enters.

D.No, never.

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: If the system is in a safe state and the Banker's Algorithm is strictly followed for all subsequent requests (only granting if the new state remains safe), deadlock is avoided. A safe state guarantees the existence of a sequence where all processes can complete.

Q41. What happens if a process requests resources such that `Request_i > Need_i`?

A.The request is granted.

B.The process waits.

C.An error condition is raised. ✅

D.The system resets.

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: This condition indicates the process is trying to request more resources than it declared as its maximum need. This violates the protocol, and the system raises an error, typically indicating a bug in the process or an invalid request.

Q42. Which of the following best describes the `Work` vector during the Safety Algorithm?

A.It remains constant.

B.It represents the total resources in the system.

C.It represents the currently available resources for simulation, increasing as processes 'finish'. ✅

D.It represents the needed resources.

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: `Work` starts as `Available`. As the algorithm finds processes that can finish (`Need_i ≤ Work`), it adds their `Allocation_i` back to `Work`. Thus, `Work` simulates the pool of available resources growing as processes complete and release their holdings.

Q43. Can the Banker's Algorithm be used for single-instance resources?

A.Yes, it is the preferred method.

B.Yes, but it is less efficient than the graph algorithm. ✅

C.No, it only works for multiple instances.

D.No, it requires at least 10 instances.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: While the text introduces it for multiple instances, the logic can technically apply to single instances (where Max/Allocation/Need are 0 or 1). However, the text notes the graph algorithm is more efficient for single instances, implying Banker's is overkill or less optimal for that specific case.

Q44. If `Available` = (1, 1, 1) and `Need_P1` = (1, 0, 0), `Need_P2` = (0, 1, 0), `Need_P3` = (0, 0, 1). Is the state safe?

A.Yes ✅

B.No

C.Cannot determine

D.Only if P1 runs first

💡 Difficulty: hard | ✅ Correct: A

📖 Explanation: P1 can run (Need (1,0,0) ≤ Work (1,1,1)). Work becomes (1,1,1) + Alloc_P1. Assuming Alloc_P1 is non-negative, Work increases. Then P2 can run, then P3. A safe sequence exists (e.g., P1, P2, P3). Thus, the state is safe.

Q45. What is the main benefit of using the Banker's Algorithm?

A.It maximizes resource utilization.

B.It guarantees deadlock avoidance. ✅

C.It is very fast.

D.It requires no prior information.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The primary goal and benefit of the Banker's Algorithm is to ensure that the system never enters an unsafe state, thereby guaranteeing that deadlock will not occur. This comes at the cost of efficiency and potentially lower resource utilization.

Q46. If a process terminates, how should the data structures be updated?

A.Remove its row from Max, Allocation, and Need.

B.Add its resources to Available.

C.Set its Finish flag to true.

D.All of the above. ✅

💡 Difficulty: hard | ✅ Correct: D

📖 Explanation: When a process terminates, it releases all resources (adding to `Available`). Its entry in the process list is effectively removed, meaning its rows in `Max`, `Allocation`, and `Need` are no longer relevant and should be removed or ignored in future calculations.

Q47. In the Resource-Request Algorithm, when is the Safety Algorithm invoked?

A.Before checking if Request ≤ Need.

B.After checking availability but before committing. ✅

C.Only if the system is currently unsafe.

D.Never.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The Safety Algorithm is invoked in Step 3, after the system has verified that the request is within limits (`Request ≤ Need`) and that resources are available (`Request ≤ Available`), and after it has tentatively updated the state. It checks if this *new* tentative state is safe.

Q48. What does it mean if `Finish[i]` remains false after the Safety Algorithm completes?

A.Process Pi is currently running.

B.Process Pi cannot complete in the current simulated sequence, indicating an unsafe state. ✅

C.Process Pi has finished.

D.Process Pi has no needs.

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: If the algorithm finishes and some `Finish[i]` are still false, it means those processes could not be satisfied with the available resources (even after simulating other processes finishing). This indicates that no safe sequence exists for the current state, making it unsafe.

Q49. Why is the vector comparison `Need_i ≤ Work` essential in the Safety Algorithm?

A.To ensure the process has enough resources to start.

B.To check if the currently simulated available resources (`Work`) can satisfy the process's remaining needs. ✅

C.To calculate the new Available vector.

D.To check if the process has exceeded its max.

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: This comparison determines if the process Pi can potentially complete in the simulated environment. If `Work` (simulated available resources) is sufficient to cover `Need_i` (remaining needs), Pi can finish, release its `Allocation`, and contribute to `Work` for other processes.

🔗 Related Topics (MCQs)

📝 Deadlocks Introduction in Operating System MCQs 📝 Deadlocks System Model in Operating System MCQs 📝 Deadlock Characterization in Operating System MCQs 📝 Necessary Conditions for Deadlock Characterization MCQs 📝 Methods for Handling Deadlocks in Operating System MCQs

←Previous Topic:Hold and Wait Deadlock Prevention📝 Banker's Algorithm in Deadlock AvoidanceNext Topic →