时间戳

首页 > 解决方案 > 通过订购 std::mutex 避免死锁

c++ - 通过订购 std::mutex 避免死锁

问题描述

这里是否有死锁避免逻辑的可移植实现（参见标记为“不可移植”的部分）：

#include <cstdint>
#include <iostream>
#include <mutex>
#include <thread>

typedef long Money; //In minor unit.

class Account {
public:
    bool transfer(Account& to,const Money amount);
    Money get_balance() const;
    Account(const Money deposit=0) : balance{deposit} {}
private:
    mutable std::mutex lock;
    Money balance;
};

bool Account::transfer(Account& to,const Money amount){
    std::unique_lock<decltype(this->lock)> flock{this->lock,std::defer_lock};
    std::unique_lock<decltype(to.lock)> tlock{to.lock,std::defer_lock};
//NON-PORTABLE:BEGIN: using intptr_t AND assuming Total Strict Order.
    const auto fi{reinterpret_cast<const std::intptr_t>(static_cast<const void*>(&this->lock))};
    const auto ti{reinterpret_cast<const std::intptr_t>(static_cast<const void*>(&to.lock))};
    if(fi<ti){
        flock.lock();
        tlock.lock();
    } else if (fi!=ti) {
        tlock.lock();
        flock.lock();
    } else {
        flock.lock();
    }
//NON-PORTABLE:END  
    this->balance-=amount;
    to.balance+=amount;
    return true;
}

Money Account::get_balance() const{
    const std::lock_guard<decltype(this->lock)> guard{this->lock};
    return this->balance;
}

void hammer_transfer(Account& from,Account& to,const Money amount, const int tries){
    for(int i{1};i<=tries;++i){
        from.transfer(to,amount);
    }
}

int main() {
    constexpr Money open_a{ 200000L};
    constexpr Money open_b{ 100000L};
    constexpr Money tran_ab{10};
    constexpr Money tran_ba{3};
    constexpr Money tran_aa{7};

    Account A{open_a};
    Account B{open_b};
    
    std::cout << "A Open:" << A.get_balance() << '\n';
    std::cout << "B Open:" << B.get_balance() << '\n';
    
    constexpr long tries{20000}; 
    std::thread TAB{hammer_transfer,std::ref(A),std::ref(B),tran_ab,tries};
    std::thread TBA{hammer_transfer,std::ref(B),std::ref(A),tran_ba,tries};
    std::thread TAA{hammer_transfer,std::ref(A),std::ref(A),tran_aa,tries};

    TAB.join();
    TBA.join();
    TAA.join();

    const auto close_a{A.get_balance()};
    const auto close_b{B.get_balance()};   
    
    std::cout << "A Close:" << close_a<< '\n';
    std::cout << "B Close:" << close_b<< '\n';
    
    int errors{0};
    if((close_a+close_b)!=(open_a+open_b)){
        std::cout << "ERROR: Money Leaked!\n";
        ++errors;
    }
    if(close_a!=(open_a+tries*(tran_ba-tran_ab)) ||
          close_b!=(open_b+tries*(tran_ab-tran_ba))
    ){
        std::cout << "ERROR: 'Lost' Transaction(s)\n";
        ++errors;
    }
    if(errors==0){
        std::cout << "* SUCCESS *\n";
    }else{
        std::cout << "** FAILED **\n";
    }
    std::cout << std::endl;
    return 0;
}

可在此处运行：https ://ideone.com/hAUfhM

这些假设是存在的（我相信足够了——有人吗？），intptr_t并且关系运算符intptr_t暗示了对它们所代表的指针值的完全严格排序。

假设的排序并不能保证，并且可能不如指针排序的不可移植性那么可移植（例如，如果intptr_t比指针更宽并且并非所有位都被写入）。

我知道关于这个和其他设计的一些不同的即兴演奏。即使不是可移植的，我也会支持所有好的答案，这些答案可以确定他们对实施的假设，理想情况下是他们适用的平台，最好是他们不适用的平台！

标签： c++concurrencyc++14language-lawyerportability

解决方案

一旦你开始出现锁争用，你就失去了这种方法，需要重新考虑整个解决方案。几乎所有的锁都会导致上下文切换，每个会花费大约 20000 个周期。

通常大多数账户要么有很多流入（商店、安排），要么有很多流出（养老金、救济金等）。

一旦您确定了竞争帐户，您可以将大量事务排队，然后锁定满足的帐户并通过 try_lock 另一个帐户运行事务，如果锁定成功，则事务完成。尝试 try_lock 几次，然后使用两个锁执行 scope_lock，其余的将这两个锁共同的所有事务。

第 2 部分。如何确保我的锁的安全排序，因为比较不在同一区域的指针是 UB。

您将唯一 ID 添加到帐户并进行比较！

推荐阅读