std :: unique_lock <std :: mutex> hoặc std :: lock_guard <std :: mutex>?

Tôi có hai trường hợp sử dụng.

A. Tôi muốn đồng bộ hóa truy cập bằng hai luồng vào hàng đợi.

B. Tôi muốn đồng bộ hóa quyền truy cập của hai luồng vào hàng đợi và sử dụng biến điều kiện vì một trong các luồng sẽ chờ nội dung được lưu vào hàng đợi bởi luồng khác.

Đối với trường hợp sử dụng AI xem ví dụ mã bằng cách sử dụng std::lock_guard<>. Đối với trường hợp sử dụng BI xem ví dụ mã sử dụng std::unique_lock<>.

Sự khác biệt giữa hai và tôi nên sử dụng cái nào trong trường hợp sử dụng?

Sự khác biệt là bạn có thể khóa và mở khóa a std::unique_lock. std::lock_guardsẽ chỉ bị khóa một lần khi xây dựng và mở khóa khi phá hủy.

Vì vậy, đối với trường hợp sử dụng B, bạn chắc chắn cần một std::unique_lockbiến điều kiện. Trong trường hợp A, nó phụ thuộc vào việc bạn có cần phải khóa lại người bảo vệ hay không.

std::unique_lockcó các tính năng khác cho phép nó, ví dụ: được xây dựng mà không khóa mutex ngay lập tức nhưng để xây dựng trình bao bọc RAII (xem tại đây ).

std::lock_guardcũng cung cấp trình bao bọc RAII thuận tiện, nhưng không thể khóa nhiều mutexes một cách an toàn. Nó có thể được sử dụng khi bạn cần một trình bao bọc cho phạm vi giới hạn, ví dụ: hàm thành viên:

class MyClass{
    std::mutex my_mutex;
    void member_foo() {
        std::lock_guard<mutex_type> lock(this->my_mutex);            
        /*
         block of code which needs mutual exclusion (e.g. open the same 
         file in multiple threads).
        */

        //mutex is automatically released when lock goes out of scope           
};

Để làm rõ một câu hỏi bằng chmike, theo mặc định std::lock_guardvà std::unique_lockgiống nhau. Vì vậy, trong trường hợp trên, bạn có thể thay thế std::lock_guardbằng std::unique_lock. Tuy nhiên, std::unique_lockcó thể có một chút chi phí.

Lưu ý rằng những ngày này nên sử dụng std::scoped_lockthay vì std::lock_guard.

lock_guardvà unique_lockkhá nhiều điều tương tự; lock_guardlà phiên bản giới hạn với giao diện giới hạn.

A lock_guardluôn luôn giữ một khóa từ xây dựng của nó để phá hủy nó. A unique_lockcó thể được tạo mà không cần khóa ngay lập tức, có thể mở khóa tại bất kỳ điểm nào trong sự tồn tại của nó và có thể chuyển quyền sở hữu khóa từ phiên bản này sang phiên bản khác.

Vì vậy, bạn luôn luôn sử dụng lock_guard, trừ khi bạn cần các khả năng của unique_lock. A condition_variablecần a unique_lock.

Sử dụng lock_guardtrừ khi bạn cần có khả năng thủ công unlockmutex ở giữa mà không phá hủy lock.

Đặc biệt, condition_variablemở khóa mutex của nó khi đi ngủ khi có cuộc gọi đến wait. Đó là lý do tại sao a lock_guardkhông đủ ở đây.

Có những điều phổ biến nhất định giữa lock_guardvà unique_locksự khác biệt nhất định.

Nhưng trong ngữ cảnh của câu hỏi, trình biên dịch không cho phép sử dụng lock_guardkết hợp với biến điều kiện, bởi vì khi một luồng xử lý chờ trên một biến điều kiện, mutex sẽ được mở khóa tự động và khi các luồng / luồng khác thông báo và luồng hiện tại được gọi (ra khỏi chờ), khóa được mua lại.

Hiện tượng này là trái với nguyên tắc lock_guard. lock_guardchỉ có thể được xây dựng một lần và phá hủy chỉ một lần.

Do đó lock_guardkhông thể được sử dụng kết hợp với một biến điều kiện, nhưng unique_lockcó thể được (vì unique_lockcó thể bị khóa và mở khóa nhiều lần).

Chúng không thực sự giống nhau, lock_guard<muType>gần giống nhau std::mutex, với một điểm khác biệt là thời gian tồn tại của nó kết thúc ở cuối phạm vi (được gọi là D-tor) nên một định nghĩa rõ ràng về hai trường hợp này:

lock_guard<muType> có một cơ chế để sở hữu một mutex trong suốt thời gian của một khối phạm vi.

Và

unique_lock<muType> là một trình bao bọc cho phép khóa hoãn lại, các nỗ lực hạn chế thời gian trong việc khóa, khóa đệ quy, chuyển quyền sở hữu khóa và sử dụng với các biến điều kiện.

Dưới đây là một ví dụ ẩn dụ:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <chrono>

using namespace std::chrono;

class Product{

   public:

       Product(int data):mdata(data){
       }

       virtual~Product(){
       }

       bool isReady(){
       return flag;
       }

       void showData(){

        std::cout<<mdata<<std::endl;
       }

       void read(){

         std::this_thread::sleep_for(milliseconds(2000));

         std::lock_guard<std::mutex> guard(mmutex);

         flag = true;

         std::cout<<"Data is ready"<<std::endl;

         cvar.notify_one();

       }

       void task(){

       std::unique_lock<std::mutex> lock(mmutex);

       cvar.wait(lock, [&, this]() mutable throw() -> bool{ return this->isReady(); });

       mdata+=1;

       }

   protected:

    std::condition_variable cvar;
    std::mutex mmutex;
    int mdata;
    bool flag = false;

};

int main(){

     int a = 0;
     Product product(a);

     std::thread reading(product.read, &product);
     std::thread setting(product.task, &product);

     reading.join();
     setting.join();


     product.showData();
    return 0;
}

Trong ví dụ này, tôi đã sử dụng unique_lock<muType>vớicondition variable

Như đã được đề cập bởi những người khác, std :: unique_lock theo dõi trạng thái bị khóa của mutex, vì vậy bạn có thể trì hoãn khóa cho đến sau khi xây dựng khóa và mở khóa trước khi phá hủy khóa. std :: lock_guard không cho phép điều này.

Dường như không có lý do tại sao các hàm chờ std :: condition_variable không nên lấy lock_guard cũng như unique_lock, bởi vì bất cứ khi nào chờ đợi kết thúc (vì bất kỳ lý do gì), mutex sẽ tự động được phản hồi để không gây ra bất kỳ vi phạm ngữ nghĩa nào. Tuy nhiên, theo tiêu chuẩn, để sử dụng std :: lock_guard với biến điều kiện, bạn phải sử dụng std :: condition_variable_any thay vì std :: condition_variable.

Chỉnh sửa : đã xóa "Sử dụng giao diện pthreads std :: condition_variable và std :: condition_variable_any phải giống hệt nhau". Nhìn vào việc thực hiện của gcc:

• std :: condition_variable :: Wait (std :: unique_lock &) chỉ gọi pthread_cond_wait () trên biến điều kiện pthread bên dưới đối với mutex được giữ bởi unique_lock (và do đó cũng có thể làm như vậy đối với lock_guard, nhưng không phải vì tiêu chuẩn không cung cấp cho điều đó)
• std :: condition_variable_any có thể hoạt động với bất kỳ đối tượng có thể khóa nào, bao gồm cả đối tượng không phải là khóa mutex (do đó, nó thậm chí có thể hoạt động với một semaphore liên tiến trình)