Sử dụng có điều kiện của tiêu chuẩn :: lock_guard

Question

Tôi có một chức năng trong đó tuyên bố foo phải được thực hiện theo lock_guard nhưng chỉ khi một con trỏ đến một đối tượng mutex đã được cung cấp cho hàm làm tham số. Nếu không, foo không phải là được bảo vệ bởi lock_guard.

tôi không có thể sử dụng các lock_guard trong một if vì khóa sẽ được phát hành ngay lập tức khi if khối kết thúc.

như vậy, mã này là vô nghĩa:

bar(std::mutex * optionalMutex = nullptr) 
{ 
    ... 
    if (nullptr != optionalMutex) { 
     std::lock_guard<std::mutex> lockScope(*optionalMutex); 
    }   <- Here the lock ends 

    foo...  <- foo is not protected when optionalMutex was provided 
} 

tôi đã cố gắng một cái gì đó như thế này:

bar(std::mutex * optionalMutex = nullptr) 
{ 
    ... 
    nullptr == optionalMutex ? 0 : std::lock_guard<std::mutex> lockScope(*optionalMutex); 

    // this scope should be protected by lock_guard when optionalMutex was provided 

    foo... 
} 

Nhiều hơn hoặc ít hơn, một trong những giải pháp duy nhất có thể đối với tôi là để lặp lại foo:

bar(std::mutex * optionalMutex = nullptr) 
{ 
    ... 
    if (nullptr != optionalMutex) { 
     std::lock_guard<std::mutex> lockScope(*optionalMutex); 
     foo... 
    } else { 
     foo... 
    } 
} 

Trình biên dịch gcc 4.9.3 không biên dịch ví dụ thứ 2 và tuân thủ ains: error: expected primary-expression before 'lockScope'. Cập nhật: Superlokkus giải thích trong câu trả lời của mình tại sao.

Nhưng tôi muốn tránh bất kỳ mã trùng lặp nào và do đó cũng trùng lặp foo.

Câu hỏi của tôi:

Có một nhã cách làm thế nào để thực hiện vấn đề này và không sử dụng trùng lặp foo. Tôi biết, tôi có thể sử dụng hàm lambda cho nhómfoo nhưng tôi tò mò nếu có giải pháp khác.

Answer 1

Làm thế nào về việc này?

void bar(std::mutex * optionalMutex = nullptr) 
{ 
     auto lockScope = (optionalMutex == nullptr) ? 
          std::unique_lock<std::mutex>() 
         : std::unique_lock<std::mutex>(*optionalMutex); 
} 

Giải thích: Trình biên dịch của bạn gặp rắc rối với tuyên bố trước vì bạn không thể thay đổi loại biểu thức thứ ba ?; tức là số 0 theo nghĩa đen không phải là std::lock_guard và ngược lại. Vì vậy, tôi đã thay đổi hai nhánh thành cùng một loại, tại đây std::unique_lock<std::mutex> vì lock_guard không được thiết kế để sử dụng mà không có một mutex hợp lệ. Nhưng vẫn thích std::lock_guard hơn std::unique_lock trong các trường hợp đơn giản hơn, vì nó sẽ làm cho mã của bạn dễ đọc hơn.

Ngoài ra tuyên bố của bạn không thể thực hiện được cho trình biên dịch, tức là ngay cả cú pháp đúng, vì biến lockScope sẽ chỉ tồn tại trong một nhánh.

Answer 2

Tôi chỉ có giải pháp này. Sử dụng một đối tượng giả mutex:

Mã này là:

bar(std::mutex * optionalMutex = nullptr) 
{ 
    ... 
    std::mutex dummyMutex; 
    std::lock_guard<std::mutex> lockScope(optionalMutex ? *optionalMutex, dummyMutex); 

    foo...  <- NOW foo is protected when optionalMutex was provided 
} 

Answer 3

Điều bạn thực sự có là hai chức năng, một chức năng khóa và một chức năng không hoạt động.Người đầu tiên có thể gọi thứ hai:

void bar() { 
    // whatever 
} 

void bar(std::mutex* mtx) { 
    std::lock_guard<std::mutex> lockScope(*mtx); 
    bar(); 
} 

Answer 4

Câu trả lời từ Superlockus là đủ tốt, nhưng tôi tự hỏi tại sao bạn không chỉ đơn giản là viết nó như thế:

bar(std::mutex * optionalMutex = nullptr) 
{ 
    if (optionalMutex) 
     optionalMutex->lock(): 

    foo... 

    if (optionalMutex) 
     optionalMutex->unlock(): 
} 

lock_guard và unique_lock được thuận tiện nhưng không phải là cách duy nhất.

Answer 5

Đó là một chuôi nhỏ nhưng bạn có thể tránh đi qua các con trỏ liệu bằng cách cho phép người gọi thông qua một std :: unique_lock thay vì:

bar(std::unique_lock<std::mutex> lockScope) 
{ 
    if(lockScope.mutex()) 
    { 
     lockScope.lock(); 
     //do things 
    } 
} 

Điều này có vẻ giống như một biểu hiện rõ ràng hơn về giao diện và làm giảm khả năng lạm dụng.