Eu tenho um aplicativo de servidor multithread que precisa de bloqueios mutex em alguma memória compartilhada.

A memória compartilhada são basicamente mapas sTL etc.

Na maioria das vezes, estou apenas lendo no mapa. Mas também preciso adicionar ocasionalmente.

por exemplo. typedef std :: map MessageMap; MessageMap msgmap; impulso: 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: Eu posso estar confundindo os diferentes tipos de bloqueio.

Qual é a diferença entre compartilhado / upgrade e exclusivo. ou seja, não entendo a explicação. Parece que, se você deseja apenas permitir muitos leitores, basta ter acesso compartilhado. E para gravar na memória compartilhada, você só precisa de acesso para atualização. Ou você precisa de exclusividade? A explicação no impulso é tudo menos clara.

O acesso à atualização foi obtido porque você pode escrever. Mas compartilhado significa que você definitivamente não escreverá, é isso que significa?

Edição: Deixe-me explicar o que estou querendo fazer com um pouco mais de clareza. Ainda não estou feliz com as respostas.

Aqui está o exemplo novamente, mas com um exemplo de algum código que também estou usando. Apenas uma ilustração, não o código real.

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