Concurrency Patterns Quiz

Q1. Concurrency means tasks run at the exact same time on multiple CPU cores. True
False

Q2. Using immutable objects in a multi-threaded program can help prevent race conditions. True
False

Q3. Which of the following describes a race condition in a concurrent program? Two threads wait forever for each other to release resources.
Two threads access and try to change the same shared data at the same time.
A program runs out of stack space due to deep recursion in multiple threads.
Threads rapidly switch execution on the CPU due to the scheduler.

Q4. A deadlock can happen if two threads each hold a lock and are waiting to acquire the other thread’s lock. True
False

Q5. Which of the following is NOT a thread-safe practice for incrementing a shared counter from multiple threads? Protecting the increment with a mutex.
Using an atomic increment instruction.
Giving each thread its own counter and combining later.
Updating a shared global counter with no synchronization.

Q6. In a classic Producer-Consumer scenario with a fixed-size buffer, how can we prevent the producer from overfilling the buffer or the consumer from reading an empty buffer? Use synchronization primitives so producers/consumers block when the buffer is full/empty.
Use a busy-wait loop where threads continuously check the buffer.
No synchronization is needed; the OS will alternate them properly.
Use multiple mutex locks on the buffer for each item slot.

Q7. Which concurrency pattern is characterized by splitting a task into subtasks that run in parallel and then joining the results? Fork/Join pattern
Producer/Consumer pattern
Actor model
Mutual exclusion pattern

Q8. Which statement is true about futures and promises? A Future represents a result that may not yet be available.
Futures require a dedicated polling thread.
A Promise is basically a thread object.
Using futures forces the main thread to block immediately.

Q9. In the Actor model of concurrency, which of the following is true? Actors do not share memory; they communicate exclusively by sending messages.
Actors use shared variables and locks to synchronize.
An actor can process multiple messages in parallel at the same time.
The Actor model only works in distributed systems, not on a single machine.

Q10. Which concurrency pattern reuses a fixed pool of worker threads to execute tasks from a queue? Thread Pool
Spinlock
Map-Reduce
Pipeline pattern

Q11. What is a key difference between a mutex (lock) and a counting semaphore? A semaphore can allow several threads concurrently; a mutex allows only one.
A mutex can be unlocked by any thread; a semaphore can only be released by the locking thread.
They are identical; a counting semaphore is just another name for a mutex.
A mutex uses busy-waiting, whereas a semaphore always blocks waiting threads.

Q12. Two threads each perform counter++ 1000 times without synchronization. What is a possible final value of the counter? Always exactly 2000
Always less than 2000
Any value from 0 to 2000, including 0
Non-deterministic but at most 2000 and likely less due to lost updates

Q13. Thread 1 acquires Lock X then Lock Y, while Thread 2 acquires Lock Y then Lock X. What concurrency issue can occur? Deadlock
Livelock
Benign race condition
No issue

Q14. Starvation is a situation where a thread never gets the CPU time or resources it needs to make progress. True
False

Q15. Adding more threads to a program will always improve performance. True
False

Q16. A lock-free algorithm guarantees that overall progress is always made without using mutual-exclusion locks. True
False

Q17. In a livelock, two or more threads are actively running and responding to each other, yet no thread is making forward progress. True
False

Q18. Which of the following is NOT one of Coffman’s four necessary deadlock conditions? Mutual exclusion
Circular wait
Resource preemption
Hold and wait

Q19. What is a common strategy to prevent deadlocks when a program must acquire multiple locks? Always acquire locks in a consistent global order.
Use at least as many threads as locks.
Hold all locks for the entire program duration.
Retry in a tight loop if acquisition fails.

Q20. Typically, a Future is a read-only placeholder for a result supplied later, whereas a Promise is a write-once object used to provide that result. True
False

design-patterns