Concurrency Fundamentals: Race Conditions and Locks Quiz Quiz

Explore essential concepts of concurrency, with a focus on race conditions, mutual exclusion, and proper lock usage. This quiz covers practical scenarios and theoretical aspects, helping you deepen your understanding of concurrent programming challenges and solutions.

1. Identifying Race Conditions

   Which of the following best defines a race condition in the context of concurrent programming?

   1. A process where threads wait indefinitely for resources
   2. A situation where the execution outcome depends on the unpredictable timing of threads
   3. A programming bug caused by incorrect array indexing
   4. A method to ensure that only one thread executes at a time

   Explanation: A race condition occurs when the output of a program is affected by the non-deterministic order of thread execution, making results unpredictable. The second option describes deadlock, not a race condition. The third option is about mutual exclusion, not the definition of a race condition. The fourth option refers to an indexing bug, which is unrelated to concurrency issues.

2. Using Locks Correctly

   If two threads increment the same shared variable simultaneously without synchronization, which problem is most likely to occur?

   1. The program will always crash
   2. The variable will become read-only
   3. Only the last increment will take effect, possibly losing data
   4. Both increments are always applied successfully

   Explanation: Without proper synchronization, both threads may read the same value and store an incremented result, causing one increment to be lost—a classic symptom of a race condition. The second option is incorrect because simultaneous unsynchronized increments can override each other. The third and fourth options rarely if ever happen as a direct consequence; crashes or read-only states are unrelated to this scenario.

3. Mutual Exclusion Purpose

   Why is mutual exclusion important when several threads access shared resources, like updating entries in a list?

   1. It prevents threads from accessing shared resources at the same time, ensuring data consistency
   2. It speeds up the execution of all threads by running them in parallel
   3. It allows each thread to have its own copy of the resource
   4. It stops threads from reading data at all

   Explanation: Mutual exclusion guarantees that only one thread can access a critical section at a time, which protects data from inconsistent or unpredictable changes. The second option describes parallelism, not mutual exclusion. The third is about thread-local resources, not mutual exclusion. The fourth incorrectly states that threads are blocked from reading entirely, which is not the purpose.

4. Lock Granularity Effects

   In the context of fine-grained versus coarse-grained locking, which is a potential drawback of using coarse-grained locks?

   1. Threads might skip critical sections altogether
   2. Complex lock management increases risk of deadlocks
   3. Higher memory usage due to many lock objects
   4. Increased contention among threads may lead to reduced concurrency

   Explanation: Coarse-grained locks guard large sections of data or code, so more threads are forced to wait, reducing concurrency. The second option is incorrect because fine-grained, not coarse-grained, locking can result in more lock objects and higher memory use. The third option is mainly a problem with fine-grained locking due to complex lock dependencies. The fourth is unrelated to lock granularity, as skipping is a logic error rather than a locking issue.

5. Deadlocks and Locks

   Consider two threads each trying to lock two resources in opposite orders. What concurrency risk does this present?

   1. A deadlock, where both threads are blocked waiting for each other
   2. Locks provide automatic resolution of such conflicts
   3. Threads will safely complete due to mutual exclusion
   4. A race condition where order of execution changes the result

   Explanation: When two threads acquire locks in different orders, they may each hold one lock and block forever waiting on the other, resulting in a deadlock. The second option is incorrect because a race condition affects result unpredictability, but deadlock causes indefinite blocking. The third is not guaranteed here, as mutual exclusion does not ensure absence of deadlock. The fourth incorrectly suggests that locks automatically resolve these conflicts; careful lock ordering is required to prevent deadlocks.