Какой механизм может атомарно заблокировать два мьютекса?

Атомарная блокировка двух мьютексов

Атомарная блокировка двух мьютексов — критическая проблема в многопоточном программировании, особенно для предотвращения deadlock ситуаций. Рассмотрим основные подходы и механизмы.

Проблема классического подхода

Если заблокировать мьютексы последовательно, возникает риск deadlock:

// Опасно!
mutex1.lock();    // Поток 1 берет mutex1
mutex2.lock();    // Может быть заблокирован

// Если другой поток имеет mutex2 и ждет mutex1 — deadlock

Решение 1: std::lock (C++11)

Самый надежный и рекомендуемый механизм:

#include <mutex>
#include <thread>

mutex mu1, mu2;

// Правильный способ
std::lock(mu1, mu2);  // Атомарно блокирует оба мьютекса
// Безопасная работа с защищенными ресурсами
mu1.unlock();
mu2.unlock();

Функция std::lock гарантирует:

• Атомарность — оба мьютекса блокируются как единая операция
• Защита от deadlock — использует внутренний алгоритм (обычно try-lock циклы)
• Поддержка произвольного числа мьютексов — std::lock(m1, m2, m3, ...)

Решение 2: std::lock_guard и std::lock

mutex mu1, mu2;

std::lock(mu1, mu2);
std::lock_guard<mutex> lg1(mu1, std::adopt_lock);
std::lock_guard<mutex> lg2(mu2, std::adopt_lock);

// Автоматическое разблокирование при выходе из области видимости

adopt_lock говорит, что мьютекс уже заблокирован.

Решение 3: std::scoped_lock (C++17, предпочтительно)

Современный и элегантный подход:

mutex mu1, mu2, mu3;

{
    std::scoped_lock lock(mu1, mu2, mu3);  // Блокирует все мьютексы
    // Критическая секция
}  // Автоматически разблокирует все

Преимущества:

• Более читаемый синтаксис
• Автоматическое управление
• Меньше ошибок
• Поддержка variadic templates

Решение 4: Упорядочивание (Ordering)

Для большого числа мьютексов:

class Resource {
    mutex mu;
    int id;  // Уникальный идентификатор
    
public:
    void transfer(Resource& other) {
        // Всегда блокируем в порядке возрастания id
        if (id < other.id) {
            std::lock(mu, other.mu);
        } else {
            std::lock(other.mu, mu);
        }
        std::lock_guard<mutex> lg1(mu, std::adopt_lock);
        std::lock_guard<mutex> lg2(other.mu, std::adopt_lock);
        
        // Безопасно выполняем операцию
    }
};

Принцип: всегда заблокируем мьютексы в одном и том же порядке — это предотвращает circular wait condition.

Решение 5: Рекурсивные мьютексы (std::recursive_mutex)

Для сценариев, когда один поток может вызывать заблокированные функции повторно:

std::recursive_mutex mu;
std::scoped_lock lock(mu);  // Может быть заблокирован несколько раз одним потоком

Рекомендации

1. Используй std::scoped_lock (C++17) как основной инструмент
2. Если C++11 — std::lock + std::lock_guard с adopt_lock
3. Избегай ручного unlock() — используй RAII паттерны
4. Упорядочивай мьютексы при работе с несколькими объектами
5. Минимизируй время в критической секции
6. Не вызывай блокирующие функции внутри критической секции (deadlock)

Правильный выбор механизма критичен для надежности многопоточных приложений.