if several processes share a variable 'mutex'. and enter the critical section, each process must execute 'wait(mutex)' to wait for the access (unlock) and then 'signal(mutex)' after completing its operation in the critical section. Considering the following lines of code. What will occur?

Question

BlackTom AI · Accepted Answer

Semaphore operations: signal (V) increments the semaphore value and wait (P) decrements it (blocking if the value would go below zero). A mutex semaphore used for mutual exclusion is typically initialized to 1 so only one process can enter the critical section after a wait.

Relevant knowledge points and concepts
1. Semaphore semantics: signal(mutex) => mutex = mutex + 1; wait(mutex) => if mutex > 0 then mutex = mutex - 1 else block.
2. A correct mutual exclusion pattern is wait(mutex) before entering the critical section and signal(mutex) after leaving it.
3. Reversing these (calling signal before entering and wait after) breaks the intended exclusion.

Step-by-step reasoning with intermediate values
Assume initial mutex = 1.
1. Process A executes signal(mutex): mutex becomes 2.
2. Process A proceeds into the critical section without doing a prior wait.
3. Before A executes wait(mutex) at the end, Process B can run the same code: signal(mutex) makes mutex = 3, and B also enters the critical section.
4. Now both A and B are concurrently inside the critical section — mutual exclusion is violated.
5. Later each process will call wait(mutex) and decrement the semaphore (e.g., 3 → 2 → 1), but that happens after they already executed the critical region.

Why the correct answer is correct
Because signal is executed before entering the critical section, the semaphore value increases and does not prevent other processes from entering. Multiple processes can therefore enter and execute the critical section concurrently.

Why the other choices are incorrect
- "a deadlock will occur": Deadlock requires processes to be waiting indefinitely; here processes are not blocked before the critical section, so no deadlock emerges from the shown order.
- "processes will starve to enter critical section": Starvation implies some never get access while others repeatedly do; with signal before entry, access is permissive, not starving.
- "all of the mentioned": Since neither deadlock nor starvation necessarily occurs, “all” is incorrect.

Conclusion
Because the signal happens before the critical section and wait after, several processes may execute in their critical section. This matches the provided correct answer.

类似问题

In Linux, a mutual exclusion applies the one of following cases.

A critical section can be as small as a single line of code.

Assume a program has 8 threads and has no race conditions. It is running on a 4-core CPU (i.e. 4-threads can run simultaneously). The number of threads running in a critical section of this program would be

Assume a program has 10 threads and has no race conditions. It is running on a 4-core CPU (i.e. 4-threads can run simultaneously). The number of threads running in a critical section of this program would be

To implement a mutual exclusion, which of the tool can be applied?

Which condition is necessary to prevent the race condition described?

What is the purpose of a mutex in concurrent programming?

Which of the following concurrency control techniques ensures that only one thread can access a resource at a time?

更多留学生实用工具

智能学习助手

风格化写作助手

论文查重助手

文献引用助手

课堂转译助手

课堂笔记助手

Quiz搜索助手

学校历年真题

智能刷题助手

智能匹配练习

希望你的学习变得更简单