Tại sao không hỗ trợ hết thời gian chờ trong std :: lock?

Question

Nếu tôi muốn lấy nhiều ổ khóa mà không cần chạy các nguy cơ bế tắc, tôi có thể sử dụng chức năng 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 

Nhưng nếu tôi muốn để có được khóa trong một thời hạn nhất định và thời gian chờ khác? Có lý do nào không có gì giống như try_until cho các khóa tương tự như wait_until cho các biến tương lai và điều kiện không?

Answer 1

Tại sao không hỗ trợ hết thời gian chờ trong std :: lock?

1. Vì không ai đề xuất.

2. Do khu vực này gây nhiều tranh cãi nên ít được đề xuất, càng có nhiều khả năng chấp nhận nó.

3. Vì chúng tôi sợ rằng nếu chúng tôi chuẩn hóa mọi thứ, bạn sẽ thấy chán.

4. Nó được để lại như một bài tập cho người đọc.

Hmm ... Tôi đang chạy ra khỏi ý tưởng ... :-)

Oh!

Nó rất dễ dàng để bạn có thể làm cho mình nếu bạn cần nó:

Cập nhật

Dưới đây là một viết lại tôi thích tốt hơn:

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

Như Anthony thấy, cảm thấy tự do để đề xuất điều này. Cũng cảm thấy tự do để chỉ sử dụng nó, và cho chúng tôi biết nếu nó thực sự hữu ích hay không.

Answer 2

std::timed_mutex có try_lock_until và try_lock_for chức năng thành viên. Tuy nhiên, bạn đúng rằng không có tương đương với std::lock với thời gian chờ.

Khóa một mutex với thời gian chờ chỉ được sử dụng trong các hốc cụ thể. Khóa nhiều mutexes với một thời gian chờ không phải là một cái gì đó bất cứ ai cảm thấy đủ mạnh về đề xuất, vì vậy nó không phải là trong C + + 11.

Ủy ban tiêu chuẩn hiện đang tích cực tìm kiếm các đề xuất cho tiêu chuẩn tiếp theo. Nếu bạn cảm thấy rằng tương đương với thời gian chờ là std::lock có giá trị, tại sao bạn không viết đề xuất?