[Multi-thread] Comment lock l'acces a un containeur de la STL ?

Hello, j'ai une application multi-thread (j'utilise la lib ACE pour créer mes thread) qui peut potentiellement (bien que rarement) accéder a deux conteneurs en même temps, et il arrivent de temps a autre qu'un élément du conteneur soit supprimé de celui-ci, et qu'un autre thread est en train de parcourir ce conteneurs => seg fault. Je pense qu'il faut donc lock l'accès au conteneurs (des maps, list, set, vector ...etc) quand elle est parcouru, mais je ne vois pas bien comment faire, et je ne sais pas si cela est possible. Merci :)

Bonjour,

Il suffit que tous tes accès aux conteneurs "locke" un mutex dédié. A toi de voir si tu créé un mutex par ressource partagé, ou bien un pour tous...
;)

Si je comprend bien, le mutex va bloquer tous les autres thread, et une fois ma liste visiter j'unlock tous les threads ? n'y a t'il pas mieux ?

il y a quelques containers que l'on peut rendre thread safe grace a des instructions assembleurs atomiques. c'est assez non portable, tres complexe (voir par exemple http://en.wikipedia.org/wiki/ABA_problem), et seuls quelques containers peuvent etre rendus thread-safe ainsi (stack, list, hash_map sur certaines architectures et encore)

En fait, je partirais dans le sens inverse : Soit ta bibliothèque de thread fournit des conteneurs avec un certain niveau de thread safety, et à la fois la sémentique de ces conteneurs et celle de la thread safety associée correspondent à ta situation, et dans ce cas tu peux les utiliser. Soit elle ne le fait pas, et alors tu dois te rabattre sur des conteneurs qui n'ont pas été conçus pour le multithread, en ajoutant manuellement les locks qui vont bien (par mutex, condition variable ou autre).

Tu devras utiliser ACE_Thread_Mutex (si tes containers ne sortent pas du processus courant), ou ACE_Process_Mutex (s'ils sont transmis à d'autres processus) autour de chaque accès à ton container, de façon à le protéger des accès concurrents.

Si tes containers sont plus lus que modifiés, alors les mutex ACE_RW_Process_Mutex (ou ACE_RW_Thread_Mutex) seront sûrement plus efficaces.

Il y a mieux et plus performant, mais ça demande d'implémenter toi-même un container conçu dans une optique thread-safe.