Concurrency considerations in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding race conditions in concurrent systems

In a system where multiple threads update a shared counter without synchronization, what is the most likely outcome?

A The counter always increments correctly without any lost updates.

B The system throws a runtime error when multiple threads access the counter.

C The counter may have incorrect values due to lost updates caused by race conditions.

D The counter resets to zero automatically after each update.

💡 Hint

Think about what happens when two threads try to update the same value at the same time.

Without synchronization, multiple threads can overwrite each other's updates, causing lost increments and incorrect counter values.

❓ Architecture

intermediate

Choosing synchronization mechanisms for shared resources

You have a shared resource accessed by multiple threads. Which synchronization mechanism is best to ensure only one thread accesses it at a time?

A Use a mutex (lock) to allow only one thread to access the resource at a time.

B Use a thread pool to manage multiple threads accessing the resource simultaneously.

C Use a queue to store all requests and process them in parallel without locks.

D Use a timer to delay access to the resource by each thread.

💡 Hint

Think about how to prevent multiple threads from entering a critical section simultaneously.

A mutex (lock) ensures mutual exclusion, allowing only one thread to access the shared resource at a time, preventing race conditions.

❓ scaling

advanced

Scaling a system with concurrent database writes

You design a system where many users write data concurrently to a database. What is a common strategy to handle high write loads without causing contention?

A Use a single-threaded application server to queue all writes sequentially.

B Use a single database server with a global lock to serialize all writes.

C Disable transactions to speed up writes and avoid locking overhead.

D Use database sharding to split data across multiple servers, reducing contention on any single server.

💡 Hint

Think about dividing the workload to avoid bottlenecks on one server.

Database sharding distributes data across multiple servers, allowing concurrent writes to different shards and reducing contention.

❓ tradeoff

advanced

Tradeoffs between optimistic and pessimistic concurrency control

Which statement best describes a tradeoff between optimistic and pessimistic concurrency control?

A Optimistic control is slower because it always locks; pessimistic control is faster because it assumes no conflicts.

B Optimistic control assumes conflicts are rare and retries on conflict; pessimistic control locks resources to prevent conflicts but can reduce concurrency.

C Optimistic control locks resources before access; pessimistic control never uses locks and always retries.

D Both optimistic and pessimistic control always lock resources but differ in lock duration.

💡 Hint

Consider how each method handles conflicts and resource locking.

Optimistic concurrency control works well when conflicts are rare by allowing concurrent access and retrying on conflicts. Pessimistic control locks resources to prevent conflicts but can reduce concurrency and cause waiting.

❓ estimation

expert

Estimating throughput for a concurrent system with locks

A system has 10 threads trying to access a shared resource protected by a lock. Each thread holds the lock for 5 milliseconds per operation. Assuming no other delays, what is the maximum number of operations the system can perform per second?

A 200 operations per second

B 100 operations per second

C 500 operations per second

D 50 operations per second

💡 Hint

Calculate how many operations fit in one second considering the lock is held exclusively.

Since only one thread can hold the lock at a time for 5 ms, each operation takes 5 ms. In one second (1000 ms), 1000 / 5 = 200 operations can be done sequentially. With 10 threads, they share the lock, but only one runs at a time, so total throughput is 200 ops/sec.