İşlemlerin birbirini engellediği ve sonsuza kadar takılı kaldığı bir duruma örnek verebilir misiniz?

Çakışma (deadlock), iki veya daha fazla sürecin (veya thread'in) aynı anda kaynakları tutması ve her birinin diğerinin serbest bırakmasını beklemesi durumunda meydana gelir. Sonuç olarak, hiçbiri çalışmaya devam edemez.

Örnek:

• A süreci R1 kaynağını alır.
• B süreci R2 kaynağını alır.
• A süreci R2 kaynağını almaya çalışır ve bekler.
• B süreci R1 kaynağını almaya çalışır ve bekler.

İki süreç birbirini bekler, bu da sonsuz bir kilitlenmeye yol açar.

C++ ile mutex kullanımıyla örnek:

#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 << "Thread 1 her iki kilidi de aldı\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 << "Thread 2 her iki kilidi de aldı\n";
}

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

Bu örnekte, eğer thread1 mtx1'i alırsa ve thread2 mtx2'yi alırsa, her ikisi de diğerinin serbest bırakmasını bekler ve bu da bir deadlock'e yol açar.