Почему std::lock() вызывает бесконечный цикл при работе с моим собственным объектом unique_lock?

Question

Я пытаюсь реализовать аналог unique_lock (это просто учебная задача, я понимаю, что стандартная реализация библиотеки работает отлично).

Я уже написал все методы, которые мне нужны, и сейчас я пытаюсь протестировать свой код на примере с https://en.cppreference.com/w/cpp/thread/unique_lock/unique_lock.

Когда дело доходит до std::lock(lk_b, lk_c); бесконечный цикл начинается.

Я сделал несколько шагов, чтобы понять, где программа теряет контроль, и в результате получается следующее: блокировка -> попытка -> разблокировка -> блокировка -> попытка -> разблокировка.

Вот частичная реализация unique_lock (я включил только те методы, которые используются в проблемной части примера).

template<typename Mutex>
class my_unique_lock {
    Mutex *lockable;
    bool is_acquired;
public:
    explicit my_unique_lock(Mutex& m): lockable{&m}, is_acquired{true}{
        lockable->lock();
        //std::cout << "constructor my_unique_lock(Mutex& m)" << std::endl;
    }

    my_unique_lock(Mutex& m, std::defer_lock_t t): lockable{&m}, is_acquired{false}{
        std::cout << "constructor my_unique_lock(Mutex& m, std::defer_lock_t t)" << std::endl;
    }

    bool try_lock(){
        std::cout << "try_lock" << std::endl;
        if(lockable == nullptr)
            throw std::system_error();
        is_acquired = mutex()->try_lock();
        return is_acquired;
    }

    void lock(){
        std::cout << "lock" << std::endl;
        if(lockable == nullptr || owns_lock())
            throw std::system_error();
        mutex()->lock();
        is_acquired = true;
    }

    void unlock(){
        //std::cout << "unlock" << std::endl;
        if(lockable == nullptr || !owns_lock())
            throw std::system_error();
        mutex()->unlock();
        is_acquired = false;
        std::cout << "unlocked" << std::endl;
    }

    Mutex *mutex() const noexcept {
        //std::cout << "*mutex()" << std::endl;
        return lockable;
    }

    bool owns_lock() const noexcept {
        //std::cout << "owns_lock()" << std::endl;
        return lockable != nullptr && is_acquired;
    }

    ~my_unique_lock(){
        //std::cout << "destructor" << std::endl;
        if(mutex() != nullptr && owns_lock()){
            mutex()->unlock();
            is_acquired = false;
        }
    }
};

И вот пример.

void update(std::mutex &m_a, std::mutex &m_b, std::mutex &m_c, int &a, int &b, int &c)
{
    {   
        my_unique_lock<std::mutex> lk(m_a);
        a++;
    }

    { 
        my_unique_lock<std::mutex> lk_b(m_b, std::defer_lock);
        my_unique_lock<std::mutex> lk_c(m_c, std::defer_lock);
        std::lock(lk_b, lk_c);
        b = std::exchange(c, b + c);
    }
}

int main()
{
    std::mutex m_a, m_b, m_c;
    int a, b, c = 1;

    std::vector<std::thread> threads;
    for (unsigned i = 0; i < 1; ++i)
        threads.emplace_back(update, std::ref(m_a), std::ref(m_b), std::ref(m_b), std::ref(a), std::ref(b), std::ref(c));

    for (auto& i: threads)
        i.join();

    std::cout << a << "'th and " << a+1 << "'th Fibonacci numbers: "
              << b << " and " << c << '\n';
}

Итак, как я уже сказал, я не очень понимаю, почему lock() вызывает бесконечный цикл с такой цепочкой вызовов (lock -> try_lock -> unlocked).

Answer 1

+ Изменить std::ref(m_b), std::ref(m_b) в std::ref(m_b), std::ref(m_c), Скопируйте / вставьте опечатку.

Ваш std::lock пытается заблокировать m_b дважды.

Другие вопросы: вы нарушаете правило 0/3/5. У вас есть несколько разных почти одинаковых замков для блокировки / разблокировки кода (рефакторинг).