Identify and fix deadlock in locked code evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.
You are given a multithreaded code snippet that acquires multiple locks and sometimes deadlocks. Identify the precise deadlock scenario and propose code changes to prevent it. Discuss techniques such as consistent lock ordering, using try-lock with backoff, timeouts, or changing lock granularity, and analyze trade-offs.
Overview: Identify and fix deadlock in locked code evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.
You have concurrent code that acquires multiple locks and occasionally deadlocks. The underlying issue is likely inconsistent lock acquisition order across threads. The goal is to identify the exact deadlock scenario and propose robust fixes. Assume two shared resources protected by two locks (A and B), and that different threads may acquire them in different orders.
Example Code (C++)
std::mutex mA;
std::mutex mB;
void thread1() {
std::unique_lock<std::mutex> lA(mA);
// ... do some work
std::unique_lock<std::mutex> lB(mB);
// critical section using A and B
}
void thread2() {
std::unique_lock<std::mutex> lB(mB);
// ... do some work
std::unique_lock<std::mutex> lA(mA);
// critical section using B and A
}
Tasks
Identify the precise deadlock scenario (the interleaving leading to deadlock).
Propose code changes to prevent deadlocks.
Discuss techniques and trade-offs: consistent lock ordering, try-lock with backoff, timeouts, and changing lock granularity.
Clarifying Questions to Ask Guidance
Clarify users, core use cases, read/write patterns, scale, latency, availability, and data retention.
State explicit assumptions before making sizing or architecture decisions.
Prioritize the functional path first, then address reliability, security, observability, and rollout.
What a Strong Answer Covers Guidance
A scoped requirements summary with concrete non-goals and success metrics.
API, data model, architecture, consistency, capacity, and operations.
Reasoned trade-offs among simple and scalable designs, including bottlenecks and failure modes.
A validation, monitoring, migration, and launch plan appropriate for the risk level.
Follow-up Questions Guidance
What breaks first at 10x traffic or data volume?
How would you degrade gracefully during dependency failures?
What metrics and alerts would prove the design is healthy after launch?