通過訂購 std::mutex 避免死鎖

Question

此處是否有死鎖避免邏輯的可移植實現（請參閱標記為“不可移植”的部分）：

#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比指針寬並且不是所有位都被寫入）。

我知道這個設計和其他設計有一些不同的即興演奏。 我會贊成所有好的答案，即使不是可移植的，也可以確定他們對實現的假設，理想情況下是一個他們適用的平台，最好是他們不適用的平台！

Answer 1

std::lock() 有一個內置的死鎖避免算法。

https://en.cppreference.com/w/cpp/thread/lock

Answer 2

一旦您開始出現鎖爭用，您就無法使用此方法，需要重新考慮整個解決方案。 幾乎所有的鎖都會導致上下文切換，每個會花費大約 20000 個周期。

通常，大多數帳戶要么有很多收款（商店、安排）要么有很多收款（養老金、救濟金等）。

一旦確定了競爭賬戶，您就可以將大量交易排隊，然后鎖定滿足的賬戶並通過 try_lock 其他賬戶運行交易，如果鎖定成功，則交易完成。 嘗試嘗試幾次 try_lock 然后使用兩個鎖執行 scope_lock 以獲取剩余的所有事務對於這兩個鎖。

第 2 部分。我如何確保我的鎖的安全排序，因為比較不在同一區域的指針是 UB。

您向帳戶添加唯一 ID 並進行比較！

Answer 3

tl;dr - 您可以在 C++20 中進行可移植的原始指針比較。 我可能會將該代碼包裝到scoped_ordered_lock或其他東西中，因為代碼仍然有點scoped_ordered_lock 。

---

假設是（我相信足夠了 - 任何人？）intptr_t 存在並且 intptr_t 上的關系運算符在保存從有效非空指針轉換為 std::mutex 的值時暗示對值進行全面嚴格排序。

不准確。 你總是對積分值總計嚴格的順序。 當從映射問題出現了intptr_t到指針是多對（在此是針對分段的地址實例的情況下這里-即TSO上intptr_t是不夠的）。

指向intptr_t映射的指針也必須是單射的（它不必是雙射，因為我們不關心某些intptr_t值是否未使用/不代表有效指針）。

無論如何，很明顯可以存在對指針的完全嚴格的排序：它只是特定於實現的。 分段地址可以標准化或扁平化等。

幸運的是，提供了一個合適的實現定義的完全嚴格排序：通過 C++20 中的 3 路函子std::compare_three_way ，以及 C++20 之前的 2 路函子less 、 greater等（也許也在 C++20 中）。

在關於宇宙飛船運算符的文本中，沒有關於實現定義的嚴格全序指針的等效語言 - 即使compare_three_way被描述為調用它 - 或關於其他關系運算符。

這似乎是故意的，因此內置運算符< 、 > 、 、 <= 、 >=和<=>不會獲得在某些平台上可能很昂貴的新約束。 實際上，2 路關系運算符被明確描述為指針的偏序。

因此，除了可移植之外，這應該與您的原始代碼相同：

const auto order = std::compare_three_way{}(&this->lock, &to.lock);
if(order == std::strong_ordering::less){
    flock.lock();
    tlock.lock();
} else if (order == std::strong_ordering::greater) {
    tlock.lock();
    flock.lock();
} else {
    flock.lock();
}

筆記

• 從 C++20 （特別是 PDF： P1961R0 ）開始，[ comparisons.general ] 說

  對於模板less 、 greater 、 less_equal和greater_equal ，任何指針類型的特化產生的結果與實現定義的嚴格指針全序一致

  這是一個較弱的要求，允許他們提供偏序，只要它從不與總序不一致。 這是否是故意削弱並不明顯，或者只是想說他們必須實施其他地方定義的相同總秩序。

• 在 C++20 之前， less等確實需要這些函子的總順序。

在任何情況下，如果您無法訪問 C++20 和compare_three_way ，則保證您的less等提供您需要的總排序。 只是不要依賴原始關系運算符。

Answer 4

這是一個自我回答以顯示修改后的代碼。 功勞是由於上面接受的答案。 對我來說，學習是因為 C++14 std::less 、 std::greater等定義了一個 Strict Total 指針，它與<和>等已經定義的偏序一致。

通過使用這些模板，現在可以保證這段代碼沒有死鎖。 在 C++20 中，它可以通過std::compare_three_way<>變得更整潔，可能更快。

https://ideone.com/ekuf2f

#include <functional>    
#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;
};

namespace{
    std::less<void*> less{};
    std::equal_to<void*> equal_to{};
}

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};
    if(less(&this->lock,&to.lock)){
        flock.lock();
        tlock.lock();
    } else if(equal_to(&this->lock,&to.lock)) {
        flock.lock();
    } else {
        tlock.lock();
        flock.lock();
    }
    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;
}