Comment itérer dessus d'un récipient dans un "thread-safe"?

J'ai un conteneur (C++) sur laquelle j'ai besoin d'opérer de deux façons, à partir de threads différents: 1) Ajouter et supprimer des éléments, et 2) l'itération à travers ses membres. Clairement, enlevez l'élément, tandis que l'itération se passe = catastrophe. Le code ressemble à ceci:

class A
{
public:
   ...
   void AddItem(const T& item, int index) { /*Put item into my_stuff at index*/ }
   void RemoveItem(const T& item) { /*Take item out of m_stuff*/ }
   const list<T>& MyStuff() { return my_stuff; } //*Hate* this, but see class C
private:
   Mutex mutex; //Goes in the *Item methods, but is largely worthless in MyStuff()
   list<T> my_stuff; //Just as well a vector or deque
};
extern A a; //defined in the .cpp file

class B
{
   ...
   void SomeFunction() { ... a.RemoveItem(item); }
};

class C
{
   ...
   void IterateOverStuff()
   {
      const list<T>& my_stuff(a.MyStuff());
      for (list<T>::const_iterator it=my_stuff.begin(); it!=my_stuff.end(); ++it)
      {
          ...
      }
   }
};

De nouveau, B::SomeFunction() et C::IterateOverStuff() sont appelé de manière asynchrone. Est-ce qu'une structure de données que je peux utiliser pour s'assurer que lors de l'itération, my_stuff est "protégé" d'ajouter ou de supprimer des opérations?

OriginalL'auteur Matt Phillips | 2011-04-14