Exemple pour stimuler shared_mutex (plusieurs lectures/d'une écriture)?

1800 de l'INFORMATION est plus ou moins correct, mais il ya quelques questions que j'ai voulu corriger.

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
}

Noter également, à la différence d'un shared_lock, un seul thread peut acquérir une upgrade_lock à un moment, même lorsqu'il n'est pas mis à jour (j'ai pensé que c'était bizarre quand je suis tombé sur ça). Ainsi, si tous vos lecteurs sont conditionnelle écrivains, vous avez besoin de trouver une autre solution.

Juste pour ajouter un peu plus empirique info, j'ai fait des études sur l'ensemble de la problématique évolutive de serrures, et Exemple pour stimuler shared_mutex (plusieurs lectures/d'une écriture)? est une bonne réponse à l'ajout de l'information importante qu'un seul thread peut avoir un upgrade_lock même si il n'est pas mis à niveau, ce qui est important car cela signifie que vous ne pouvez pas mettre à niveau à partir d'un verrou partagé d'un unique verrouillage sans relâcher le verrou partagé en premier. (Ce point a été discuté ailleurs mais le plus intéressant thread est ici http://thread.gmane.org/gmane.comp.lib.boost.devel/214394)

Toutefois j'en ai trouvé un d'important (sans-papiers) la différence entre un thread en attente d'une mise à niveau vers un verrou (ie doit attendre que tous les lecteurs de libération du verrou partagé) et un verrou en écriture d'attente pour la même chose (c'est à dire une unique_lock).

1. Le thread est en attente d'une unique_lock sur le shared_mutex bloque les nouveaux lecteurs de venir, ils doivent attendre que les écrivains de la demande. Cela garantit lecteurs de ne pas mourir de faim écrivains (toutefois, je crois que les écrivains pourraient mourir de faim lecteurs).

2. Le thread est en attente d'une upgradeable_lock de mise à niveau permet à d'autres threads pour obtenir un verrou partagé, de sorte que ce fil pourrait être affamé " si les lecteurs sont très fréquentes.

C'est une question importante à envisager, et devrait probablement être documentées.

Grande réponse par Jim Morris, je suis tombé sur ce et il m'a fallu un certain temps pour comprendre. Voici un code simple qui montre qu'après l'envoi d'une "demande" pour un unique_lock boost (version 1.54) bloque tous les shared_lock demandes. C'est très intéressant car il me semble que le choix entre unique_lock et upgradeable_lock permet si nous voulons écrire prioritaire ou non prioritaire.

Aussi (1) de Jim Morris post semble contredire ce:
Boost shared_lock. Lire préféré?

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