📝 Monitors in Process synchronization (49 MCQs)

📖 From Operating System • 5. Process Synchronization • 49 questions available

←Previous Topic:Functional Programming Languages Alternative Approache in Process Synchronization📝 Monitors in Process synchronizationDining Philosophers Solution Using Monitors in Process synchronization:Next Topic→

What is Monitors in Process synchronization?

Definition:
A monitor is a high-level language construct encapsulating shared variables, procedures, and implicit mutual exclusion, ensuring only one process executes within the monitor at any time $t$ .

Example:
A bounded buffer monitor contains $buffer[N]$ , $count$ , and procedures $put(x)$ and $get()$ with automatic locking upon entry.

Reason:
Monitors reduce programming errors by bundling synchronization logic with data, eliminating explicit lock/unlock pairs and making correctness easier to verify than raw semaphores.

Easy

Medium

Hard

📝 All Monitors in Process synchronization MCQs

Q1. Semaphores, while convenient for process synchronization, can lead to timing errors that are:

A.Always reproducible

B.Easy to detect and fix

C.Difficult to detect and rarely occur ✅

D.Impossible to occur in modern systems

💡 Difficulty: easy | ✅ Correct: C

📖 Explanation: Timing errors in semaphore usage are difficult to detect because they only occur during specific execution sequences that do not always happen. These rare and non-reproducible errors make debugging particularly challenging, often requiring extensive testing to uncover the issues.

Q2. What is a fundamental high-level synchronization construct developed to address errors in semaphore usage?

A.Semaphore

B.Mutex

C.Monitor ✅

D.Condition variable

💡 Difficulty: easy | ✅ Correct: C

📖 Explanation: A monitor is a fundamental high-level synchronization construct developed to overcome the difficulties and errors associated with using semaphores incorrectly. Monitors provide a structured approach to synchronization that helps prevent common programming mistakes.

Q3. In the semaphore solution to the critical-section problem, what is the initial value of the `mutex` semaphore?

A.0

B.1 ✅

C.2

D.The number of processes

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: The `mutex` semaphore is initialized to 1 to provide mutual exclusion for the critical section. This binary semaphore ensures that only one process can enter its critical section at a time by requiring each process to perform `wait(mutex)` before entering and `signal(mutex)` after leaving.

Q4. What type of error can occur if a process replaces `signal(mutex)` with `wait(mutex)` after the critical section?

A.Mutual exclusion violation

B.Deadlock ✅

C.Race condition

D.Starvation

💡 Difficulty: easy | ✅ Correct: B

📖 Explanation: Replacing `signal(mutex)` with `wait(mutex)` after the critical section will cause a deadlock. The process that has already executed the critical section will try to acquire the mutex again (which is already held by itself), blocking forever and preventing other processes from entering.

Q5. If a process omits the `wait(mutex)` operation before entering the critical section, what synchronization problem occurs?

A.Deadlock

B.Starvation

C.Mutual exclusion is violated ✅

D.The system crashes

💡 Difficulty: easy | ✅ Correct: C

📖 Explanation: Omitting `wait(mutex)` before entering the critical section violates mutual exclusion. Without acquiring the lock, multiple processes can enter their critical sections simultaneously, leading to race conditions and potential data corruption. The `mutex` semaphore provides the necessary mutual exclusion guarantee.

Q6. A monitor type in a programming language typically contains which of the following?

A.Only shared variable declarations

B.Only function definitions

C.Shared variable declarations, function definitions, and initialization code ✅

D.Only initialization code

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: A monitor type consists of three main components: shared variable declarations (the data), function definitions (the procedures that operate on the data), and initialization code. This structure encapsulates both data and operations, similar to how classes work in object-oriented programming.

Q7. What is the primary motivation for developing high-level synchronization constructs like monitors?

A.To make programs run faster

B.To make synchronization easier and prevent common errors ✅

C.To replace all uses of semaphores

D.To reduce the number of processes

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: High-level constructs like monitors were developed to make synchronization easier and prevent the subtle errors that occur with low-level primitives like semaphores. They provide a structured approach that helps programmers avoid common mistakes such as incorrect ordering or omission of synchronization operations.

Q8. What happens if a process swaps the order of `wait()` and `signal()` operations on the `mutex` semaphore, executing `signal(mutex)` before the critical section?

A.Deadlock occurs

B.The process starves

C.Mutual exclusion is violated ✅

D.The system crashes

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: Swapping the order, so that `signal(mutex)` is executed before entering the critical section, will violate mutual exclusion. The process releases the lock before performing its critical section, allowing other processes to also enter their critical sections simultaneously, potentially leading to race conditions.

Q9. What is the result of a process replacing `signal(mutex)` with `wait(mutex)` in the critical-section solution?

A.The critical section is executed correctly

B.The process will deadlock ✅

C.Other processes can enter the critical section

D.The mutex value becomes 0

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: Replacing `signal(mutex)` with `wait(mutex)` after the critical section causes the process to attempt to acquire a mutex it already holds, resulting in deadlock. The process blocks indefinitely, and no other process can enter the critical section because the mutex is never released.

Q10. If a process omits both `wait(mutex)` and `signal(mutex)` in the critical-section solution, what is the likely outcome?

A.The system functions normally

B.Mutual exclusion is violated and the system may deadlock ✅

C.Only deadlock occurs

D.Only mutual exclusion is violated

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: Omitting both operations can lead to both mutual exclusion violation and potential deadlock. Without `wait(mutex)`, processes can enter the critical section freely, violating mutual exclusion. Additionally, if a process blocks while in the critical section without releasing the mutex, it can cause deadlock.

Q11. Why are timing errors with semaphores difficult to detect?

A.They always crash the system immediately

B.They occur only during specific, non-reproducible execution sequences ✅

C.They are always caught by the compiler

D.They are obvious to all programmers

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: Timing errors with semaphores are difficult to detect because they manifest only during particular execution sequences that do not always occur. These rare conditions make errors hard to reproduce in testing environments, allowing subtle bugs to remain undetected until they occur in production.

Q12. What is the correct sequence of operations for a process using a semaphore to enter a critical section?

A.signal(mutex), critical section, wait(mutex)

B.wait(mutex), critical section, wait(mutex)

C.wait(mutex), critical section, signal(mutex) ✅

D.signal(mutex), critical section, signal(mutex)

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: The correct sequence is to first execute `wait(mutex)` to acquire the lock before entering the critical section, and then execute `signal(mutex)` after leaving the critical section to release the lock. This ensures mutual exclusion and prevents other processes from accessing the critical section concurrently.

Q13. In the semaphore solution to the critical-section problem, an honest programming error or uncooperative programmer can cause difficulties. What is one such difficulty?

A.The program becomes too fast

B.The program uses too much memory

C.Several processes may be executing in their critical sections simultaneously ✅

D.The program runs correctly

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: A programming error can cause several processes to execute in their critical sections simultaneously. This violates mutual exclusion and can lead to race conditions. Such errors may not be immediately obvious and can be difficult to identify, as they may not always be reproducible.

Q14. Why were high-level language constructs like monitors developed?

A.To replace all low-level programming languages

B.To deal with errors that arise from incorrect semaphore usage ✅

C.To make programs more complex

D.To eliminate the need for synchronization

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: High-level constructs were developed specifically to deal with errors arising from incorrect semaphore usage. Semaphores require careful programming to avoid mistakes in ordering and omission, and these errors can lead to deadlock or mutual exclusion violations. Monitors provide a more structured and safer approach to synchronization.

Q15. What is the syntax for declaring a monitor in a programming language?

A.monitor monitor_name { ... } ✅

B.monitor_name { ... }

C.type monitor_name { ... }

D.monitor_name = { ... }

💡 Difficulty: medium | ✅ Correct: A

📖 Explanation: The syntax for declaring a monitor is `monitor monitor_name { ... }`. This encapsulates the shared data declarations, function definitions, and initialization code within a single structured unit. The monitor name identifies the specific synchronization construct being defined.

Q16. What type of error is most likely if a process incorrectly omits `signal(mutex)` after its critical section?

A.The system will run faster

B.Mutual exclusion is still guaranteed

C.A deadlock will occur ✅

D.Other processes will be able to enter immediately

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: If a process omits `signal(mutex)` after its critical section, the mutex semaphore will never be released. Any other process attempting to execute `wait(mutex)` will block forever, resulting in a deadlock. This is a classic example of how simple omissions in semaphore usage can lead to serious synchronization problems.

Q17. Consider the scenario where a process executes `signal(mutex)` before the critical section. What is the primary consequence?

A.The process starves

B.The process deadlocks

C.Mutual exclusion is violated ✅

D.The system runs correctly

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: Executing `signal(mutex)` before the critical section releases the lock prematurely. Since the critical section is still being executed, another process can acquire the mutex and also enter its critical section. Both processes are now in their critical sections simultaneously, violating the mutual exclusion requirement.

Q18. Consider the scenario where a process executes `wait(mutex)` before and after the critical section. What is the primary consequence?

A.Mutual exclusion is violated

B.The process starves

C.A deadlock occurs ✅

D.The system functions correctly

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: Executing `wait(mutex)` both before and after the critical section creates a deadlock. The first `wait()` acquires the mutex. After the critical section, the second `wait()` tries to acquire the same mutex, which is already held by the process itself. Since the process is waiting for its own lock, it blocks indefinitely.

Q19. What is the consequence of a process omitting `wait(mutex)` before entering the critical section but correctly executing `signal(mutex)` after?

A.Mutual exclusion is violated ✅

B.The process deadlocks

C.The system runs correctly

D.The process starves

💡 Difficulty: hard | ✅ Correct: A

📖 Explanation: Omitting `wait(mutex)` means the process does not acquire the mutex lock before entering its critical section. This violates mutual exclusion because other processes can also enter the critical section without acquiring the lock. Even though the process correctly executes `signal(mutex)` after, the lock was never acquired, so the signal is ineffective.

Q20. What is the consequence of a process correctly executing `wait(mutex)` before entering the critical section but omitting `signal(mutex)` after?

A.Mutual exclusion is violated

B.The process deadlocks ✅

C.Other processes can still enter the critical section

D.The system continues normally

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: If a process correctly acquires the mutex with `wait(mutex)` but fails to release it with `signal(mutex)` after the critical section, the mutex is never released. Other processes that try to acquire the mutex will block indefinitely, causing a deadlock. The system will grind to a halt as no other process can enter the critical section.

Q21. The examples of incorrect semaphore usage illustrate that these errors:

A.Are easily caught by the compiler

B.Can be generated easily when programmers use semaphores incorrectly ✅

C.Only happen with complex programs

D.Never occur in practice

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: The examples demonstrate that various types of errors can be generated easily when programmers use semaphores incorrectly. Even simple mistakes like swapping or omitting operations can lead to serious synchronization problems such as mutual exclusion violations and deadlocks.

Q22. Which of the following is a correct statement about monitors?

A.Monitors are a low-level synchronization primitive

B.Monitors were developed to prevent errors in semaphore usage ✅

C.Monitors cannot be used for process synchronization

D.Monitors are less effective than semaphores

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: Monitors are a high-level synchronization construct developed to prevent errors in semaphore usage. They provide a structured approach to synchronization that encapsulates shared data and operations, making it harder for programmers to make mistakes that lead to deadlock or mutual exclusion violations.

Q23. A monitor type is most similar to which concept in object-oriented programming?

A.A function

B.A class ✅

C.A variable

D.A semaphore

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: A monitor type is most similar to a class in object-oriented programming. Both encapsulate data (shared variables) and methods (functions) together. The monitor provides a structured way to manage shared resources and synchronize access, similar to how a class encapsulates data and the methods that operate on it.

Q24. In a monitor, where are the shared variable declarations placed?

A.Inside the function definitions

B.Inside the initialization code

C.Inside the monitor body ✅

D.Outside the monitor

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: Shared variable declarations are placed inside the monitor body. These variables represent the shared data that the monitor is responsible for synchronizing access to. The functions within the monitor operate on these shared variables, providing controlled access to the data.

Q25. What is the purpose of the initialization code in a monitor?

A.To declare shared variables

B.To define functions

C.To set initial values for shared data ✅

D.To provide error handling

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: The initialization code in a monitor is used to set initial values for the shared data. Just like in a class constructor, this code executes when the monitor is first created, ensuring that the shared variables start in a consistent and known state before any functions are called.

Q26. If a process executes `wait(mutex)` before the critical section and `wait(mutex)` after, what is the state of the mutex semaphore after the first `wait()`?

A.0 ✅

B.1

C.2

D.The value remains unchanged

💡 Difficulty: hard | ✅ Correct: A

📖 Explanation: After the first `wait(mutex)` operation, the mutex semaphore value becomes 0. This indicates that the mutex is locked and currently held by the process that executed the `wait()`. Other processes attempting `wait(mutex)` will block until the mutex is released with `signal(mutex)`.

Q27. If a process executes `wait(mutex)` before the critical section and `wait(mutex)` after, what happens to the second `wait()` operation?

A.It acquires the mutex again

B.It blocks indefinitely ✅

C.It releases the mutex

D.It completes successfully

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: The second `wait(mutex)` operation blocks indefinitely because the mutex is already held by the same process. Since the mutex value is 0, `wait()` decrements it to -1 and blocks. The process is waiting for a lock it already holds, creating a classic deadlock situation.

Q28. What is the most serious consequence of a process swapping `wait()` and `signal()` operations?

A.The process finishes faster

B.The process uses less memory

C.Mutual exclusion is violated ✅

D.The process starves

💡 Difficulty: hard | ✅ Correct: C

📖 Explanation: The most serious consequence is that mutual exclusion is violated. By releasing the lock (`signal()`) before entering the critical section, the process allows other processes to also enter their critical sections concurrently. This can lead to race conditions and data corruption, which are extremely difficult to debug.

Q29. What is the primary purpose of monitors as a high-level synchronization construct?

A.To make programs more complex

B.To provide a structured approach to synchronization ✅

C.To eliminate all concurrency

D.To replace semaphores completely

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: The primary purpose of monitors is to provide a structured approach to synchronization. By encapsulating shared data and operations, monitors make it easier for programmers to write correct concurrent programs and prevent common errors associated with low-level primitives like semaphores.

Q30. In a monitor, functions that operate on shared data are known as:

A.Monitor functions ✅

B.Semaphore functions

C.Critical functions

D.Synchronized functions

💡 Difficulty: medium | ✅ Correct: A

📖 Explanation: Functions that operate on shared data within a monitor are called monitor functions. These functions provide controlled access to the shared variables, ensuring that only one function executes within the monitor at a time. This structure helps maintain data consistency and prevent race conditions.

Q31. What is the result if a process omits the `signal(mutex)` operation but correctly executes `wait(mutex)` before the critical section?

A.The process continues normally

B.Other processes can still enter the critical section

C.A deadlock occurs ✅

D.Mutual exclusion is violated

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: Omitting `signal(mutex)` after the critical section causes a deadlock. The mutex remains locked, and any other process attempting to enter the critical section via `wait(mutex)` will block indefinitely. The system becomes stuck, unable to make progress.

Q32. What is the result if a process omits the `wait(mutex)` operation but correctly executes `signal(mutex)` after the critical section?

A.Mutual exclusion is violated ✅

B.A deadlock occurs

C.The process blocks

D.The system runs correctly

💡 Difficulty: medium | ✅ Correct: A

📖 Explanation: Omitting `wait(mutex)` means the process does not acquire the mutex before entering the critical section. This violates mutual exclusion because multiple processes can enter their critical sections simultaneously. The `signal(mutex)` operation releases a lock that was never acquired, which has no effect on the synchronization.

Q33. How does a monitor prevent mutual exclusion violations?

A.By using semaphores internally

B.By ensuring only one function executes within the monitor at a time ✅

C.By using condition variables

D.By preventing multiple processes from calling monitor functions

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: A monitor prevents mutual exclusion violations by ensuring that only one function executes within the monitor at any given time. This is achieved through implicit mutual exclusion, where the monitor enforces that a process calling a monitor function has exclusive access to the monitor's shared data.

Q34. What component of a monitor is responsible for setting the initial state of shared variables?

A.Function definitions

B.Shared variable declarations

C.Initialization code ✅

D.The monitor name

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: The initialization code is responsible for setting the initial state of shared variables in a monitor. This code executes when the monitor is first created, ensuring that all shared data starts in a consistent state before any monitor functions are called by processes.

Q35. If a process correctly executes `wait(mutex)` and `signal(mutex)` but another process incorrectly uses `signal(mutex)` without `wait(mutex)`, what is the effect?

A.The system crashes

B.Mutual exclusion may be violated ✅

C.The correct process deadlocks

D.No effect occurs

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: If a process uses `signal(mutex)` without first executing `wait(mutex)`, it releases a lock it doesn't hold. This can increase the mutex value beyond 1, potentially allowing multiple processes to pass through a subsequent `wait(mutex)` and violate mutual exclusion. This demonstrates how a single misbehaving process can corrupt the synchronization state.

Q36. What is a potential consequence of the `signal(mutex)` operation being executed by a process that didn't acquire the mutex?

A.The process deadlocks

B.The mutex value can exceed 1 ✅

C.The system runs correctly

D.Mutual exclusion is guaranteed

💡 Difficulty: hard | ✅ Correct: B

📖 Explanation: Executing `signal(mutex)` without first acquiring the mutex increments the semaphore value. This can make the mutex value greater than 1. Consequently, multiple processes might be able to execute `wait(mutex)` successfully and enter their critical sections simultaneously, violating mutual exclusion.

Q37. What is the role of function definitions in a monitor?

A.To declare shared variables

B.To set initial values

C.To define operations on shared data ✅

D.To provide error handling

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: Function definitions in a monitor specify the operations that can be performed on the shared data. These functions are the only way for processes to interact with the data managed by the monitor. They ensure that all access to the shared data occurs in a controlled and synchronized manner.

Q38. How does a monitor help prevent deadlocks?

A.By providing a structured approach to resource acquisition ✅

B.By using semaphores for all synchronization

C.By preventing processes from waiting

D.By using condition variables

💡 Difficulty: hard | ✅ Correct: A

📖 Explanation: A monitor helps prevent deadlocks by providing a structured approach to synchronization and resource acquisition. The encapsulation of shared data and functions within a monitor makes it easier to ensure that locks are acquired and released correctly, reducing the likelihood of the circular wait condition that leads to deadlock.

Q39. What is the purpose of the `mutex` semaphore in the critical-section problem?

A.To count the number of processes

B.To provide mutual exclusion ✅

C.To synchronize process execution

D.To allocate resources

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The `mutex` semaphore is specifically used to provide mutual exclusion for the critical section. By initializing it to 1 and requiring processes to perform `wait(mutex)` before entering and `signal(mutex)` after leaving, the semaphore ensures that at most one process can be in its critical section at a time.

Q40. If a process executes `wait(mutex)` correctly but another process fails to execute `wait(mutex)`, what is the likely outcome?

A.Mutual exclusion is violated ✅

B.A deadlock occurs

C.The system functions correctly

D.The process starves

💡 Difficulty: hard | ✅ Correct: A

📖 Explanation: Even if one process correctly uses `wait(mutex)`, another process that omits it can enter the critical section without acquiring the lock. This violates mutual exclusion, as both processes can be in their critical sections simultaneously. The incorrect process undermines the synchronization mechanism for all processes.

Q41. What is the relationship between monitors and semaphores?

A.Monitors replace semaphores completely

B.Monitors are a higher-level construct that helps prevent errors in using low-level primitives like semaphores ✅

C.Monitors are less powerful than semaphores

D.Monitors are a type of semaphore

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: Monitors are a higher-level synchronization construct that helps prevent errors commonly made when using low-level primitives like semaphores. While semaphores are still useful, monitors provide a more structured and safer approach to synchronization by encapsulating data and operations.

Q42. What is the primary advantage of using monitors over semaphores?

A.Monitors are faster

B.Monitors provide better performance

C.Monitors are easier to use correctly and reduce programming errors ✅

D.Monitors can handle more processes

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: The primary advantage of monitors is that they are easier to use correctly than semaphores. By providing a structured encapsulation of shared data and operations, monitors reduce the likelihood of common programming errors such as incorrect ordering or omission of synchronization operations.

Q43. What is the correct order of operations in the semaphore solution to the critical-section problem?

A.critical section, wait(mutex), signal(mutex)

B.wait(mutex), signal(mutex), critical section

C.wait(mutex), critical section, signal(mutex) ✅

D.signal(mutex), critical section, wait(mutex)

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: The correct order is to execute `wait(mutex)` to acquire the lock before the critical section and `signal(mutex)` to release the lock after the critical section. This ensures that the critical section is protected by mutual exclusion and that the lock is properly released for other processes.

Q44. What does the `wait()` operation do to a semaphore value?

A.Increments it

B.Decrements it ✅

C.Sets it to 0

D.Leaves it unchanged

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: The `wait()` operation decrements the semaphore value. If the value is greater than 0, the operation completes successfully, and the process acquires the lock. If the value is 0 or negative, the process blocks until the semaphore value increases. This mechanism is fundamental to semaphore-based synchronization.

Q45. What does the `signal()` operation do to a semaphore value?

A.Increments it ✅

B.Decrements it

C.Sets it to 1

D.Leaves it unchanged

💡 Difficulty: medium | ✅ Correct: A

📖 Explanation: The `signal()` operation increments the semaphore value. This releases the lock if the process held it, or increases the semaphore count if it was used as a counting semaphore. The `signal()` operation also unblocks any processes waiting on the semaphore, allowing them to proceed.

Q46. The monitor construct is typically available in which type of programming languages?

A.Only assembly languages

B.Only low-level languages

C.High-level programming languages ✅

D.Only scripting languages

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: Monitors are typically available in high-level programming languages as a language construct. They are not present in low-level languages like assembly, which rely on simpler synchronization primitives. Monitors were developed as a high-level abstraction to make synchronization easier and more reliable.

Q47. If a process incorrectly places `wait(mutex)` after `signal(mutex)` in the critical-section solution, what is the likely outcome?

A.Mutual exclusion is violated ✅

B.A deadlock occurs

C.The system runs correctly

D.The process starves

💡 Difficulty: hard | ✅ Correct: A

📖 Explanation: If `signal(mutex)` is executed before `wait(mutex)`, the process releases the lock before entering the critical section, allowing other processes to enter simultaneously. This violates mutual exclusion. The `wait(mutex)` after the critical section is executed after the critical section, which doesn't prevent the violation.

Q48. What is the purpose of a monitor's shared variable declarations?

A.To define the monitor's functions

B.To set initial values

C.To specify the data that needs synchronized access ✅

D.To provide error handling

💡 Difficulty: medium | ✅ Correct: C

📖 Explanation: Shared variable declarations in a monitor specify the data that needs synchronized access. These variables represent the shared resources that processes will access through the monitor's functions. The monitor ensures that all access to these variables is properly synchronized to prevent race conditions.

Q49. What is a monitor type in the context of process synchronization?

A.A low-level kernel primitive

B.A high-level synchronization construct ✅

C.A type of semaphore

D.A hardware mechanism

💡 Difficulty: medium | ✅ Correct: B

📖 Explanation: A monitor type is a high-level synchronization construct used in process synchronization. It provides a structured way to manage shared resources by encapsulating data and operations within a single unit. Monitors are designed to make synchronization easier and more reliable than using low-level primitives like semaphores.

🔗 Related Topics (MCQs)

📝 Process Synchronization in operating system MCQs 📝 The Critical Section Problem in Process Synchronization MCQs 📝 Peterson's Solution MCQs 📝 Synchronization hardware in operating system MCQs 📝 Mutex Locks in Process Synchronization MCQs