Ví dụ cho boost shared_mutex (nhiều lần đọc / một lần ghi)?

Tôi có một ứng dụng đa luồng phải đọc một số dữ liệu thường xuyên và đôi khi dữ liệu đó được cập nhật. Ngay bây giờ mutex giữ quyền truy cập vào dữ liệu đó an toàn, nhưng nó đắt tiền vì tôi muốn nhiều luồng có thể đọc đồng thời và chỉ khóa chúng khi cần cập nhật (luồng cập nhật có thể đợi các luồng khác hoàn thành) .

Tôi nghĩ đây là những gì boost::shared_mutexphải làm, nhưng tôi không rõ về cách sử dụng nó và chưa tìm thấy một ví dụ rõ ràng.

Có ai có một ví dụ đơn giản mà tôi có thể sử dụng để bắt đầu không?

Có vẻ như bạn sẽ làm điều gì đó như sau:

boost::shared_mutex _access;
void reader()
{
  // get shared access
  boost::shared_lock<boost::shared_mutex> lock(_access);

  // now we have shared access
}

void writer()
{
  // get upgradable access
  boost::upgrade_lock<boost::shared_mutex> lock(_access);

  // get exclusive access
  boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);
  // now we have exclusive access
}

1800 INFORMATION ít nhiều đúng, nhưng có một số vấn đề tôi muốn sửa.

boost::shared_mutex _access;
void reader()
{
  boost::shared_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access
}

void conditional_writer()
{
  boost::upgrade_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access

  if (something) {
    boost::upgrade_to_unique_lock< boost::shared_mutex > uniqueLock(lock);
    // do work here, but now you have exclusive access
  }

  // do more work here, without anyone having exclusive access
}

void unconditional_writer()
{
  boost::unique_lock< boost::shared_mutex > lock(_access);
  // do work here, with exclusive access
}

Cũng xin lưu ý, không giống như shared_lock, chỉ một luồng duy nhất có thể có được một lift_lock tại một thời điểm, ngay cả khi nó không được nâng cấp (điều mà tôi nghĩ là rất khó xử khi gặp phải nó). Vì vậy, nếu tất cả độc giả của bạn đều là những người viết có điều kiện, bạn cần tìm giải pháp khác.

Kể từ C ++ 17 (VS2015), bạn có thể sử dụng tiêu chuẩn cho khóa đọc-ghi:

#include <shared_mutex>

typedef std::shared_mutex Lock;
typedef std::unique_lock< Lock > WriteLock;
typedef std::shared_lock< Lock > ReadLock;

Lock myLock;


void ReadFunction()
{
    ReadLock r_lock(myLock);
    //Do reader stuff
}

void WriteFunction()
{
     WriteLock w_lock(myLock);
     //Do writer stuff
}

Đối với phiên bản cũ hơn, bạn có thể sử dụng boost với cú pháp tương tự:

#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>

typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock >  WriteLock;
typedef boost::shared_lock< Lock >  ReadLock;

Chỉ để thêm một số thông tin kinh nghiệm khác, tôi đã điều tra toàn bộ vấn đề về các ổ khóa có thể nâng cấp và Ví dụ về tăng shared_mutex (nhiều lần đọc / một lần ghi)? là một câu trả lời hay, bổ sung thêm thông tin quan trọng rằng chỉ một luồng có thể có một khóa nâng cấp ngay cả khi nó không được nâng cấp, điều đó quan trọng vì nó có nghĩa là bạn không thể nâng cấp từ khóa chia sẻ lên một khóa duy nhất mà không giải phóng khóa chia sẻ trước. (Điều này đã được thảo luận ở nơi khác nhưng chủ đề thú vị nhất là ở đây http://thread.gmane.org/gmane.comp.lib.boost.devel/214394 )

Tuy nhiên, tôi đã tìm thấy một sự khác biệt quan trọng (không có tài liệu) giữa một luồng đang chờ nâng cấp lên một khóa (tức là cần đợi tất cả người đọc giải phóng khóa chia sẻ) và một khóa người viết đang chờ điều tương tự (tức là một unique_lock).

1. Chuỗi đang chờ unique_lock trên shared_mutex chặn bất kỳ độc giả mới nào đến, họ phải đợi người viết yêu cầu. Điều này đảm bảo độc giả không bỏ đói nhà văn (tuy nhiên tôi tin rằng nhà văn có thể bỏ đói độc giả).

2. Chuỗi đang chờ nâng cấp có thể nâng cấp cho phép các chủ đề khác nhận được khóa chia sẻ, do đó, chuỗi này có thể bị bỏ đói nếu người đọc rất thường xuyên.

Đây là một vấn đề quan trọng cần xem xét, và có lẽ nên được ghi lại.

Sử dụng một semaphore có số lượng bằng số lượng độc giả. Hãy để mỗi người đọc lấy một số lượng semaphore để đọc, theo cách đó tất cả họ có thể đọc cùng một lúc. Sau đó, hãy để người viết lấy TẤT CẢ các số đếm semaphore trước khi viết. Điều này khiến người viết phải đợi tất cả các lần đọc kết thúc và sau đó chặn các lần đọc trong khi viết.

Phản hồi tuyệt vời của Jim Morris, tôi tình cờ phát hiện ra điều này và tôi phải mất một lúc để hình dung. Dưới đây là một số đoạn mã đơn giản cho thấy rằng sau khi gửi "yêu cầu" tăng unique_lock (phiên bản 1.54) sẽ chặn tất cả các yêu cầu shared_lock. Điều này rất thú vị vì dường như đối với tôi, việc lựa chọn giữa unique_lock và upgradedable_lock cho phép nếu chúng ta muốn ưu tiên ghi hoặc không ưu tiên.

Ngoài ra (1) trong bài đăng của Jim Morris dường như mâu thuẫn với điều này: Boost shared_lock. Đọc ưa thích?

#include <iostream>
#include <boost/thread.hpp>

using namespace std;

typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock > UniqueLock;
typedef boost::shared_lock< Lock > SharedLock;

Lock tempLock;

void main2() {
    cout << "10" << endl;
    UniqueLock lock2(tempLock); // (2) queue for a unique lock
    cout << "11" << endl;
    boost::this_thread::sleep(boost::posix_time::seconds(1));
    lock2.unlock();
}

void main() {
    cout << "1" << endl;
    SharedLock lock1(tempLock); // (1) aquire a shared lock
    cout << "2" << endl;
    boost::thread tempThread(main2);
    cout << "3" << endl;
    boost::this_thread::sleep(boost::posix_time::seconds(3));
    cout << "4" << endl;
    SharedLock lock3(tempLock); // (3) try getting antoher shared lock, deadlock here
    cout << "5" << endl;
    lock1.unlock();
    lock3.unlock();
}