What are some examples of deadlock in C++?

What are some examples of deadlock in C++?

Deadlock in C++ occurs when two or more threads are blocked forever, each waiting for the other to release a resource. A common example is when two threads each hold a lock on a resource and try to acquire the lock held by the other.

Can you give a specific code example?

Sure! Here's a simple example:

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

std::mutex mutex1;
std::mutex mutex2;

void thread1() {
    std::lock_guard<std::mutex> lock1(mutex1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock2(mutex2); // This can cause deadlock
}

void thread2() {
    std::lock_guard<std::mutex> lock2(mutex2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock1(mutex1); // This can cause deadlock
}

int main() {
    std::thread t1(thread1);
    std::thread t2(thread2);
    t1.join();
    t2.join();
    return 0;
}

In this example, if thread1 locks mutex1 and then tries to lock mutex2, while thread2 locks mutex2 and then tries to lock mutex1, a deadlock occurs.

How can I prevent deadlocks in my code?

To prevent deadlocks, you can use several strategies:

1. Lock Ordering: Always acquire locks in a consistent order.
2. Try-Lock: Use try-lock mechanisms to avoid waiting indefinitely.
3. Timeouts: Implement timeouts when trying to acquire locks.
4. Resource Hierarchy: Design your system to avoid circular wait conditions.