¿Por qué no hay soporte de tiempo de espera en std :: lock?

Question

Si quiero agarrar múltiples cerraduras sin correr el riesgo de estancamiento, puedo usar la función std::lock:

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 

Pero lo que si quiero adquirir las cerraduras en un plazo determinado de tiempo de espera y de lo contrario? ¿Hay alguna razón por la cual no hay nada como try_until para cerraduras que es similar a wait_until para futuros y variables de condición?

Answer 1

¿Por qué no timeout support in std :: lock?

1. Porque nadie propuso.

2. Porque esta área era tan controvertida que cuanto menos se proponía, más posibilidades tenía de ser aceptada.

3. Porque teníamos miedo de que si estandarizáramos todo, se aburrirían.

4. Se dejó como un ejercicio para el lector.

Hmm ... Me estoy quedando sin ideas ... :-)

Oh!

Es fácil para que usted pueda hacer usted mismo si lo necesita:

actualización

Aquí es una reescritura me gusta más:

#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); 
} 

Como sugiere Anthony, no dude en proponer esta. También siéntase libre de usarlo, y avísenos si fue realmente útil o no.

Answer 2

std::timed_mutex tiene try_lock_until y try_lock_for funciones de miembro. Sin embargo, tiene razón en que no hay un equivalente de std::lock con un tiempo de espera agotado.

El bloqueo de un mutex con un tiempo de espera solo se utiliza en nichos específicos. Bloquear múltiples mutexes con un tiempo de espera no es algo que nadie haya tenido la suficiente confianza como para proponer, por lo que no está en C++ 11.

El comité de estándares actualmente está buscando activamente propuestas para la próxima norma. Si considera que un valor de tiempo de espera equivalente a std::lock es valioso, ¿por qué no escribir una propuesta?