Как можно избежать deadlock

1️⃣ Как кратко ответить

Избежать deadlock можно, следуя четырем основным стратегиям: избегание взаимного блокирования ресурсов, соблюдение порядка захвата блокировок, использование таймаутов и применение алгоритмов обнаружения и восстановления. Эти методы помогают предотвратить ситуации, когда несколько потоков или процессов блокируют друг друга, ожидая освобождения ресурсов.

2️⃣ Подробное объяснение темы

Deadlock (взаимная блокировка) — это ситуация, когда два или более потоков или процессов блокируют друг друга, ожидая освобождения ресурсов, которые удерживаются другими участниками. Это приводит к состоянию, когда ни один из них не может продолжить выполнение. Рассмотрим основные стратегии для предотвращения deadlock.

1. Избегание взаимного блокирования ресурсов

Взаимное блокирование ресурсов происходит, когда два или более потоков удерживают ресурсы и ожидают освобождения других ресурсов, удерживаемых другими потоками. Чтобы избежать этого, можно использовать стратегию, при которой каждый поток запрашивает все необходимые ресурсы одновременно. Если все ресурсы не могут быть предоставлены, поток освобождает уже удерживаемые ресурсы и повторяет попытку позже.

2. Соблюдение порядка захвата блокировок

Установление фиксированного порядка захвата блокировок может предотвратить deadlock. Если все потоки захватывают блокировки в одном и том же порядке, то ситуация, когда один поток удерживает ресурс, а другой ожидает его, не возникнет. Это достигается путем назначения уникального идентификатора каждому ресурсу и захвата ресурсов в порядке возрастания этих идентификаторов.

Пример:

#include <mutex>
#include <thread>
​
std::mutex mutex1;
std::mutex mutex2;
​
void threadFunction() {
    // Захват блокировок в фиксированном порядке
    std::lock(mutex1, mutex2);
    std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);
​
    // Критическая секция
    // ...
​
    // Блокировки будут автоматически освобождены при выходе из области видимости
}
​
int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
​
    t1.join();
    t2.join();
​
    return 0;
}

В этом примере оба потока захватывают mutex1 и mutex2 в одном и том же порядке, что предотвращает deadlock.

3. Использование таймаутов

Таймауты позволяют потокам ожидать освобождения ресурсов только в течение определенного времени. Если ресурс не становится доступным в течение этого времени, поток может освободить уже удерживаемые ресурсы и повторить попытку позже. Это предотвращает бесконечное ожидание.

Пример:

#include <mutex>
#include <thread>
#include <chrono>
#include <iostream>
​
std::mutex mutex1;
std::mutex mutex2;
​
void threadFunction() {
    while (true) {
        // Попытка захватить первую блокировку с таймаутом
        if (mutex1.try_lock_for(std::chrono::milliseconds(100))) {
            std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
​
            // Попытка захватить вторую блокировку с таймаутом
            if (mutex2.try_lock_for(std::chrono::milliseconds(100))) {
                std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);
​
                // Критическая секция
                // ...
​
                return; // Успешно завершили работу
            }
        }
​
        // Освобождение ресурсов и повторная попытка
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
​
int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
​
    t1.join();
    t2.join();
​
    return 0;
}

4. Применение алгоритмов обнаружения и восстановления

Алгоритмы обнаружения и восстановления позволяют системе обнаруживать deadlock и предпринимать действия для его устранения. Это может включать принудительное завершение одного из процессов или освобождение ресурсов.

Эти стратегии помогают разработчикам создавать более надежные многопоточные приложения, минимизируя риск возникновения deadlock.