Contoh untuk meningkatkan shared_mutex (banyak baca / satu tulisan)?

Saya memiliki aplikasi multithread yang harus sering membaca beberapa data, dan terkadang data tersebut diperbarui. Saat ini mutex menjaga akses ke data itu tetap aman, tetapi itu mahal karena saya ingin beberapa utas dapat membaca secara bersamaan, dan hanya menguncinya ketika pembaruan diperlukan (utas pembaruan dapat menunggu utas lain selesai) .

Saya pikir inilah yang boost::shared_mutexseharusnya dilakukan, tetapi saya tidak jelas tentang cara menggunakannya, dan belum menemukan contoh yang jelas.

Adakah yang punya contoh sederhana yang bisa saya gunakan untuk memulai?

Sepertinya Anda akan melakukan sesuatu seperti ini:

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 INFORMASI kurang lebih benar, tetapi ada beberapa masalah yang ingin saya perbaiki.

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
}

Juga Perhatikan, tidak seperti shared_lock, hanya satu utas yang dapat memperoleh upgrade_lock pada satu waktu, bahkan ketika itu tidak ditingkatkan (yang menurut saya canggung ketika saya menemukannya). Jadi, jika semua pembaca Anda adalah penulis bersyarat, Anda perlu mencari solusi lain.

Sejak C ++ 17 (VS2015) Anda dapat menggunakan standar untuk kunci baca-tulis:

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

Untuk versi yang lebih lama, Anda dapat menggunakan boost dengan sintaks yang sama:

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

Hanya untuk menambahkan beberapa info empiris, saya telah menyelidiki seluruh masalah kunci yang dapat diupgrade, dan Contoh untuk meningkatkan shared_mutex (banyak baca / satu tulisan)? adalah jawaban yang bagus menambahkan info penting bahwa hanya satu utas yang dapat memiliki upgrade_lock meskipun tidak ditingkatkan, itu penting karena itu berarti Anda tidak dapat meningkatkan dari kunci bersama menjadi kunci unik tanpa melepaskan kunci bersama terlebih dahulu. (Ini telah dibahas di tempat lain tetapi utas yang paling menarik ada di sini http://thread.gmane.org/gmane.comp.lib.boost.devel/214394 )

Namun saya menemukan perbedaan penting (tidak berdokumen) antara utas menunggu peningkatan ke kunci (yaitu perlu menunggu semua pembaca untuk melepaskan kunci bersama) dan kunci penulis menunggu hal yang sama (yaitu unique_lock).

1. Utas yang menunggu unique_lock di shared_mutex memblokir pembaca baru yang masuk, mereka harus menunggu permintaan penulis. Hal ini memastikan pembaca tidak membuat penulis kelaparan (namun saya yakin penulis dapat membuat pembaca kelaparan).

2. Utas yang menunggu upgradeable_lock untuk meningkatkan memungkinkan utas lain mendapatkan kunci bersama, jadi utas ini bisa kelaparan jika pembaca sangat sering.

Ini adalah masalah penting untuk dipertimbangkan, dan mungkin harus didokumentasikan.

Gunakan semaphore dengan hitungan yang sama dengan jumlah pembaca. Biarkan setiap pembaca mengambil satu hitungan semafor untuk membaca, dengan cara itu mereka semua dapat membaca pada waktu yang sama. Kemudian biarkan penulis mengambil SEMUA hitungan semaphore sebelum menulis. Hal ini menyebabkan penulis menunggu semua pembacaan selesai dan kemudian memblokir pembacaan saat menulis.

Tanggapan yang luar biasa oleh Jim Morris, saya menemukan ini dan butuh beberapa saat untuk memikirkannya. Berikut adalah beberapa kode sederhana yang menunjukkan bahwa setelah mengirimkan "request" untuk unique_lock boost (versi 1.54) memblokir semua permintaan shared_lock. Ini sangat menarik karena menurut saya memilih antara unique_lock dan upgradeable_lock memungkinkan jika kita ingin menulis prioritas atau tanpa prioritas.

Juga (1) dalam posting Jim Morris tampaknya bertentangan dengan ini: Boost shared_lock. Baca lebih disukai?

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