Czy możesz podać przykład sytuacji, w której dochodzi do wzajemnego blokowania procesów, uniemożliwiającego im dalsze działanie?

Zakleszczenie wzajemne (deadlock) występuje, gdy dwa lub więcej procesów (lub wątków) jednocześnie utrzymuje zasoby i każdy z nich oczekuje na zwolnienie zasobu, który jest utrzymywany przez inny proces. W rezultacie żaden z nich nie może kontynuować pracy.

Przykład:

• Proces A przejmuje zasób R1.
• Proces B przejmuje zasób R2.
• Proces A próbuje przejąć zasób R2 i zostaje zablokowany, oczekując na jego zwolnienie.
• Proces B próbuje przejąć zasób R1 i również zostaje zablokowany.

Oba procesy oczekują na siebie nawzajem, co prowadzi do nieskończonego zablokowania.

Przykład w C++ z mutexami:

#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 << "Wątek 1 przejął oba locki\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 << "Wątek 2 przejął oba locki\n";
}

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

W tym przykładzie, może wystąpić deadlock, jeśli thread1 zdobędzie mtx1, a thread2 mtx2, i oboje będą oczekiwać na zwolnienie zasobu, którego drugi trzyma.