Exploring Deadlocks and Avoiding Them

Welcome to another crucial chapter in your journey through C++ concurrency. Previously, we explored inter-thread communication with condition variables, which allow threads to efficiently coordinate activities. In this lesson, we focus on another vital aspect of concurrency: understanding and avoiding deadlocks. Deadlocks occur when two or more threads are unable to proceed because each is holding a resource the other needs. This lesson will equip you with the knowledge to identify and prevent these potential pitfalls in multithreaded programming.

In this unit, you will gain a comprehensive understanding of what deadlocks are, how they occur, and strategies to avoid them:

• Understanding Deadlocks: We’ll provide an overview of the conditions necessary for a deadlock to occur, helping you understand the roots of the problem.

• Code Example: Recognizing a Deadlock Situation: You'll see a code example showing how a deadlock can arise when two threads attempt to acquire locks in an inconsistent order:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx1, mtx2;

void thread1() {
    std::lock_guard<std::mutex> lock1(mtx1);  // thread1 locks mtx1
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // Simulate some work
    std::cout << "Thread 1 trying to lock mtx2\n";
    std::lock_guard<std::mutex> lock2(mtx2);  // thread1 tries to lock mtx2
    std::cout << "Thread 1 acquired both locks\n";
}

void thread2() {
    std::lock_guard<std::mutex> lock1(mtx2);  // thread2 locks mtx2
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // Simulate some work
    std::cout << "Thread 2 trying to lock mtx1\n";
    std::lock_guard<std::mutex> lock2(mtx1);  // thread2 tries to lock mtx1
    std::cout << "Thread 2 acquired both locks\n";
}

int main() {
    std::thread t1(thread1);
    std::thread t2(thread2);

    t1.join();
    t2.join();

    return 0;
}

If we run this code, we'll encounter a deadlock situation where both threads are waiting for each other to release the locks they need to proceed causing the program to hang indefinitely.

Let's take a look at a scenario where a deadlock occurs:

1. thread1 acquires mtx1.
2. thread2 acquires mtx2.
3. thread1 tries to acquire mtx2, but it's already locked by thread2 and waits.
4. thread2 tries to acquire mtx1, but it's already locked by thread1 and waits.
5. Thus both threads are waiting for each other to release the locks they need, causing a deadlock.

Let's understand how we can avoid such situations by following best practices and strategies to prevent deadlocks.

To avoid deadlocks, you can follow these strategies:

• Acquire Locks in a Consistent Order: Always acquire locks in the same order to prevent deadlocks. This strategy ensures that threads consistently acquire locks in a predictable sequence, reducing the likelihood of circular dependencies.

Here is how this would work:

• thread1 acquires mtx1.
• thread2 tries to acquire mtx1 but waits until thread1 releases it.
• thread1 acquires mtx2 and finishes its work.
• thread2 acquires mtx1 and then mtx2.
• Both threads complete their tasks without any deadlock.

Here is an example of acquiring locks in a consistent order:

void thread1() {
    std::lock_guard<std::mutex> lock1(mtx1);  // thread1 locks mtx1
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // Simulate some work
    std::cout << "Thread 1 trying to lock mtx2\n";
    std::lock_guard<std::mutex> lock2(mtx2);  // thread1 locks mtx2
    std::cout << "Thread 1 acquired both locks\n";
}

void thread2() {
    std::lock_guard<std::mutex> lock1(mtx1);  // thread2 locks mtx1
    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // Simulate some work
    std::cout << "Thread 2 trying to lock mtx2\n";
    std::lock_guard<std::mutex> lock2(mtx2);  // thread2 locks mtx2
    std::cout << "Thread 2 acquired both locks\n";
}

In this revised example, both threads acquire locks in the same order, ensuring consistency and preventing deadlocks.

• Use Lock Hierarchies: Establish a hierarchy for acquiring locks to prevent circular dependencies. By defining a consistent order for acquiring locks, you can avoid deadlocks caused by inconsistent lock acquisition.

Here is an example of using lock hierarchies:

void thread1() {
    std::lock(mtx1, mtx2);  // Acquire locks in a consistent order
    std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);  // Adopt the lock
    std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);  // Adopt the lock
    std::cout << "Thread 1 acquired both locks\n";
}

void thread2() {
    std::lock(mtx1, mtx2);  // Acquire locks in a consistent order
    std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);  // Adopt the lock
    std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);  // Adopt the lock
    std::cout << "Thread 2 acquired both locks\n";
}

Notice, that we use std::lock to acquire both locks in a consistent order. std::lock is a method that locks multiple mutexes simultaneously, preventing deadlocks by ensuring that the locks are acquired in a consistent order.

Pay attention to the std::adopt_lock parameter in the std::lock_guard constructor. This parameter indicates that the mutex is already locked and should be adopted by the lock_guard – note that the mutex was locked using std::lock before creating the lock_guard.

By adopting the lock, we avoid reacquiring the mutex and ensure that the locks are acquired in the correct order.

By following these strategies, you can prevent deadlocks and ensure the smooth execution of multithreaded programs. Understanding the conditions that lead to deadlocks and adopting best practices for lock acquisition will help you write robust and reliable concurrent code.