Exemple d'utilisation de boost extensible mutex

J'ai une application serveur multithread qui a besoin d'exclusion mutuelle verrous sur certains de mémoire partagée.

La mémoire partagée sont essentiellement sTL cartes etc.

La plupart du temps, je suis juste de la lecture de la carte.
Mais, j'ai aussi besoin de temps en temps de l'ajouter à elle.

par exemple
typedef std::map MessageMap;
MessageMap msgmap;
boost:shared_mutex access_;

void ProcessMessage(Message* message)
{
  // Access message... read some stuff from it  message->...

  UUID id = message->GetSessionID();

  //Need to obtain a lock here. (shared lock? multiple readers)
  //How is that done?
  boost::interprocess::scoped_lock(access_);

  //Do some readonly stuff with msgmap
  MessageMap::iterator it = msgmap.find();
  //

  //Do some stuff...

  //Ok, after all that I decide that I need to add an entry to the map.
  //how do I upgrade the shared lock that I currently have?
  boost::interprocess::upgradable_lock


  //And then later forcibly release the upgrade lock or upgrade and shared lock if I'm not looking
  //at the map anymore.
  //I like the idea of using scoped lock in case an exception is thrown, I am sure that
  //all locks are released.
}

EDIT:
Je suis peut-être à confondre les différents types de verrou.

Quoi la différence entre shared/mise à niveau et exclusif.
c'est à dire que je ne comprends pas l'explication.
Il sonne comme si vous voulez juste pour permettre un grand nombre de lecteurs, d'un accès partagé est tout ce que vous voulez obtenir. Et pour écrire à votre mémoire partagée, vous avez juste besoin de mise à niveau de l'accès. Ou avez-vous besoin d'exclusivité? L'explication en boost est loin d'être claire.

Est la mise à niveau de l'accès obtenu, parce que vous pouvez écrire. Mais partagée signifie que vous certainement n'est pas écrire, c'est que ce que cela signifie?

EDIT: Laissez-moi vous expliquer ce que je suis désireux de le faire avec un peu plus de clarté. Je ne suis pas encore satisfaite des réponses.

Voici l'exemple de tous les plus de nouveau, mais avec un exemple de code que j'utilise.
Juste une illustration, pas le code.

typedef boost::shared_mutex Mutex;
typedef boost::shared_lock<Mutex> ReadLock;
typedef boost::unique_lock<Mutex> WriteLock;
Mutex mutex;
typedef map<int, int> MapType;    //Your map type may vary, just change the typedef
MapType mymap;
void threadoolthread() //There could be 10 of these.
{   
//Add elements to map here
int k = 4;   //assume we're searching for keys equal to 4
int v = 0;   //assume we want the value 0 associated with the key of 4
ReadLock read(mutex); //Is this correct?
MapType::iterator lb = mymap.lower_bound(k);
if(lb != mymap.end() && !(mymap.key_comp()(k, lb->first)))
{
//key already exists
}
else
{
//Acquire an upgrade lock yes?  How do I upgrade the shared lock that I already        have?
//I think then sounds like I need to upgrade the upgrade lock to exclusive is that correct as well?
//Assuming I've got the exclusive lock, no other thread in the thread pool will be able to insert.
//the key does not exist in the map
//add it to the map
{
WriteLock write(mutex, boost::adopt_lock_t());  //Is this also correct?
mymap.insert(lb, MapType::value_type(k, v));    //Use lb as a hint to insert,
//so it can avoid another lookup
}
//I'm now free to do other things here yes?  what kind of lock do I have here, if any?  does the readlock still exist?
}

OriginalL'auteur Matt | 2010-10-09