Mutex locks in Operating Systems - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary purpose of a mutex lock?

Choose the best explanation for why mutex locks are used in operating systems.

A To prevent multiple threads from accessing a shared resource at the same time, ensuring exclusive access.

B To allow multiple threads to access a shared resource simultaneously without restrictions.

C To speed up the execution of threads by running them in parallel without any synchronization.

D To permanently block a thread from accessing any resource once it has been locked.

💡 Hint

Think about what happens when two threads try to change the same data at once.

Mutex locks ensure that only one thread can access a shared resource at a time, preventing conflicts and data corruption.

📋 Factual

intermediate

Which condition does a mutex lock help to avoid?

Identify the problem that mutex locks are designed to prevent in concurrent programming.

A Memory leak due to improper resource allocation.

B Deadlock caused by threads waiting indefinitely for resources.

C Race condition where multiple threads access and modify shared data simultaneously.

D Stack overflow from excessive recursive calls.

💡 Hint

Consider what happens when two threads try to update the same variable at the same time.

Mutex locks prevent race conditions by ensuring that only one thread can modify shared data at a time.

🔍 Analysis

advanced

What happens if a thread tries to acquire a mutex lock that is already held by another thread?

Analyze the behavior of threads when a mutex lock is unavailable.

A The thread immediately acquires the lock and proceeds.

B The thread causes the program to crash due to a deadlock.

C The thread skips the critical section and continues execution.

D The thread is blocked and waits until the lock becomes available.

💡 Hint

Think about what must happen if two threads want the same exclusive resource.

If a mutex is already locked, other threads trying to acquire it will wait (block) until it is released.

❓ Comparison

advanced

How does a mutex lock differ from a semaphore?

Choose the statement that correctly distinguishes mutex locks from semaphores.

A A mutex is a locking mechanism for exclusive access, while a semaphore can allow multiple accesses based on its count.

B A mutex is used only for process synchronization, while semaphores are used only for thread synchronization.

C A mutex automatically releases itself after a fixed time, but a semaphore must be manually released.

D A mutex allows multiple threads to enter the critical section simultaneously, while a semaphore allows only one.

💡 Hint

Consider how many threads can access a resource at once with each mechanism.

Mutexes provide exclusive access (one thread at a time), while semaphores can allow multiple threads up to a set limit.

❓ Reasoning

expert

What is a potential risk if a thread holding a mutex lock terminates without releasing it?

Consider the consequences in a system when a mutex lock is not properly released.

A Other threads will automatically acquire the lock and continue safely.

B The mutex lock remains locked indefinitely, causing other threads to block forever (deadlock).

C The operating system forcibly releases the lock immediately without any issues.

D The system ignores the lock and allows all threads to access the resource simultaneously.

💡 Hint

Think about what happens if a resource is never unlocked.

If a mutex is never released, other threads waiting for it will block forever, causing a deadlock situation.

Practice

1. What is the main purpose of a mutex lock in operating systems?

easy

A. To store data permanently on the disk

B. To speed up the execution of multiple processes simultaneously

C. To allow only one process to access a shared resource at a time

D. To create multiple copies of a resource for each process

Solution

1. Step 1: Understand the role of mutex locks

   Mutex locks are used to control access to shared resources so that only one process can use the resource at a time.

2. Step 2: Identify the correct purpose

   The main goal is to prevent conflicts and errors by ensuring exclusive access, which matches To allow only one process to access a shared resource at a time.

3. Final Answer:

   To allow only one process to access a shared resource at a time -> Option C

4. Quick Check:

   Mutex = exclusive access [OK]

Hint: Mutex means one user at a time [OK]

Common Mistakes:

• Thinking mutex speeds up all processes
• Confusing mutex with data storage
• Believing mutex duplicates resources

2. Which of the following is the correct sequence when using a mutex lock?

easy

A. Acquire the lock, use the resource, then release the lock

B. Release the lock, use the resource, then acquire the lock

C. Use the resource, acquire the lock, then release the lock

D. Use the resource, release the lock, then acquire the lock

Solution

1. Step 1: Recall the correct mutex usage order

   To safely use a shared resource, a process must first acquire the mutex lock before accessing it.

2. Step 2: Complete the sequence

   After using the resource, the process must release the lock so others can access it. This matches Acquire the lock, use the resource, then release the lock.

3. Final Answer:

   Acquire the lock, use the resource, then release the lock -> Option A

4. Quick Check:

   Acquire -> Use -> Release [OK]

Hint: Always lock before use, unlock after [OK]

Common Mistakes:

• Releasing before acquiring
• Using resource without locking
• Locking after using resource

3. Consider this pseudocode using a mutex lock:

mutex.lock()
shared_counter = shared_counter + 1
mutex.unlock()

If two threads run this code simultaneously starting with shared_counter = 5, what is the final value of shared_counter?

medium

A. 6

B. 5

C. Error

D. 7

Solution

1. Step 1: Understand mutex effect on shared_counter

   The mutex lock ensures only one thread increments the counter at a time, preventing race conditions.

2. Step 2: Calculate final value after two increments

   Starting at 5, each thread adds 1 safely, so final value is 5 + 2 = 7.

3. Final Answer:

   7 -> Option D

4. Quick Check:

   Mutex prevents race, count increments twice [OK]

Hint: Mutex ensures both increments count [OK]

Common Mistakes:

• Assuming only one increment happens
• Ignoring mutex effect causing race
• Expecting an error without reason

4. A programmer wrote this code snippet:

mutex.unlock()
use_shared_resource()
mutex.lock()

What is the main problem with this code?

medium

A. The mutex is unlocked before it is locked

B. The code will cause a deadlock

C. The mutex is locked twice without unlocking

D. There is no problem; the code is correct

Solution

1. Step 1: Analyze the order of mutex operations

   The code calls mutex.unlock() before any mutex.lock(), which is incorrect because you cannot release a lock you don't hold.

2. Step 2: Identify the error

   This misuse can cause runtime errors or undefined behavior, matching The mutex is unlocked before it is locked.

3. Final Answer:

   The mutex is unlocked before it is locked -> Option A

4. Quick Check:

   Unlock before lock is wrong [OK]

Hint: Lock first, unlock later; never reverse [OK]

Common Mistakes:

• Unlocking before locking
• Ignoring lock before resource use
• Assuming double lock is okay

5. In a system with multiple threads, which scenario best shows why mutex locks are essential?

hard

A. Two threads perform calculations independently without sharing data

B. Two threads write to the same file simultaneously without locking, causing data corruption

C. A single thread writes to a file without any other threads running

D. Two threads read different files at the same time without any locks

Solution

1. Step 1: Identify when mutex locks are needed

   Mutex locks are essential when multiple threads access and modify the same shared resource to avoid conflicts.

2. Step 2: Match scenario with mutex necessity

   Two threads write to the same file simultaneously without locking, causing data corruption describes simultaneous writes causing corruption, which mutex locks prevent by serializing access.

3. Final Answer:

   Two threads write to the same file simultaneously without locking, causing data corruption -> Option B

4. Quick Check:

   Shared write needs mutex [OK]

Hint: Mutex needed when sharing writable resource [OK]

Common Mistakes:

• Thinking mutex needed for independent reads
• Assuming single thread needs mutex
• Confusing calculation with shared resource access