Dlaczego brak obsługi timeout w std :: lock?

Question

Jeśli chcę złapać kilka zamków bez narażania się impasu, mogę użyć std::lock funkcję:

int data1, data2; 
std::mutex m1, m2; 
std::unique_lock<std::mutex> lock1(m1, std::defer_lock); 
std::unique_lock<std::mutex> lock2(m2, std::defer_lock); 

std::lock(lock1, lock2);   // guaranteed deadlock-free 

// work with data1 and data2 

ale co jeśli chcę nabyć zamki w określonym terminie i limitu czasu w inny sposób? Czy istnieje powód, dla którego nie ma nic takiego jak try_until dla zamków podobnych do wait_until dla zmiennych futures i warunków?

Answer 1

Dlaczego brak obsługi timeout w std :: lock?

1. Ponieważ nikt nie zaproponował go.

2. Ponieważ ten obszar był tak kontrowersyjny, że im mniej proponowano, tym bardziej prawdopodobne, że zostanie zaakceptowany.

3. Ponieważ baliśmy się, że jeśli wszystko ustandaryzujemy, znudzisz się.

4. Zostało to jako ćwiczenie dla czytelnika.

Hmm ... Biegnę z pomysłów ... :-)

Oh!

Jest łatwo można zrobić samemu, jeśli jest to potrzebne:

Aktualizacja

Oto przepisać Lubię lepiej:

#include <mutex> 
#include <chrono> 

template <class Clock, class Duration, class L0, class L1> 
int 
try_lock_until(std::chrono::time_point<Clock, Duration> t, L0& l0, L1& l1) 
{ 
    std::unique_lock<L0> u0(l0, t); 
    if (u0.owns_lock()) 
    { 
     if (l1.try_lock_until(t)) 
     { 
      u0.release(); 
      return -1; 
     } 
     else 
      return 1; 
    } 
    return 0; 
} 

template <class Rep, class Period, class L0, class L1> 
int 
try_lock_for(std::chrono::duration<Rep, Period> d, L0& l0, L1& l1) 
{ 
    return try_lock_until(std::chrono::steady_clock::now() + d, l0, l1); 
} 


int main() 
{ 
    std::timed_mutex m1, m2; 
    try_lock_for(std::chrono::milliseconds(50), m1, m2); 
} 

Jak sugeruje Anthony, nie krępuj się zaproponować to. Możesz też po prostu go użyć i poinformować nas, czy rzeczywiście było przydatne, czy nie.

Answer 2

std::timed_mutex ma try_lock_until i try_lock_for funkcji członka. Jednak masz rację, że nie ma odpowiednika std::lock z limitem czasu.

Blokowanie muteksu z limitem czasu jest przydatne tylko w określonych niszy. Zablokowanie wielu muteksów z limitem czasu nie było czymś, na co ktoś miałby ochotę zaproponować, więc nie jest to w C++ 11.

Komitet normalizacyjny aktywnie poszukuje obecnie propozycji na następny standard. Jeśli uważasz, że odpowiedni dla czasu oczekiwania odpowiednik std::lock jest wartościowy, czemu nie napisać propozycji?