Tudna példát mondani olyan helyzetre, amikor folyamatok kölcsönösen blokkolják egymást, és örökre megakadnak?

Kölcsönös zárolás (deadlock) akkor fordul elő, amikor két vagy több folyamat (vagy szál) egyidejűleg tart erőforrásokat, és mindegyik várja, hogy a másik felszabadítson egy erőforrást. Ennek eredményeként egyik sem tud tovább haladni.

Példa:

• Az A folyamat megszerzi az R1 erőforrást.
• A B folyamat megszerzi az R2 erőforrást.
• Az A folyamat megpróbálja megszerezni az R2 erőforrást, és blokkolva vár.
• A B folyamat megpróbálja megszerezni az R1 erőforrást, és szintén blokkolva vár.

Mindkét folyamat a másikat várja, ami végtelen blokkoláshoz vezet.

C++ példában mutexekkel:

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

std::mutex mtx1, mtx2;

void thread1() {
    std::lock_guard<std::mutex> lock1(mtx1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock2(mtx2);
    std::cout << "Szál 1 mindkét zárolást megszerezte\n";
}

void thread2() {
    std::lock_guard<std::mutex> lock2(mtx2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::lock_guard<std::mutex> lock1(mtx1);
    std::cout << "Szál 2 mindkét zárolást megszerezte\n";
}

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

Ebben a példában deadlock fordulhat elő, ha az egyik szál megszerzi az mtx1-et, a másik pedig az mtx2-t, és mindketten várnak a másik felszabadítására.