Deadlock Prevention

A Deadlock occurs when two or more threads are blocked indefinitely, each waiting for a resource held by another. Understanding deadlock conditions and prevention strategies is critical for system reliability.

Resolving Deadlocks with std::scoped_lock

If Thread A locks Mutex 1 and waits for Mutex 2, while Thread B locks Mutex 2 and waits for Mutex 1, a deadlock occurs.

C++17's std::scoped_lock accepts multiple mutexes and locks them atomically without deadlocking, using algorithms that roll back acquisitions if contention is detected.

Code Walkthrough

Demonstrates a safe transfer operation between two objects using std::scoped_lock.

#include <iostream>
#include <mutex>
#include <thread>
class Account {
public:
    std::mutex m_mutex;
    int m_balance;
Account(int bal) : m_balance(bal) {}
};
void transfer(Account& from, Account& to, int amount) {
    // std::scoped_lock acquires locks for both accounts atomically without deadlocking
    std::scoped_lock lock(from.m_mutex, to.m_mutex);
if (from.m_balance >= amount) {
        from.m_balance -= amount;
        to.m_balance += amount;
        std::cout << "Transferred " << amount << " successfully.\n";
    }
}
int main() {
    Account a(100);
    Account b(50);
std::thread t1(transfer, std::ref(a), std::ref(b), 20);
    std::thread t2(transfer, std::ref(b), std::ref(a), 10);
t1.join();
    t2.join();
    return 0;
}

Interview-Relevant Information