est `std :: map <..> a; blah = a [abcd]; `thread sécurisé si abcd n'a pas été créé avant cet appel?

Question

Nous avons donc créé une carte. Nous voulons obtenir some_type blah = map_variable[some_not_inserted_yet_value] cela appellerait ajouter un nouvel élément à la carte si l'un n'a pas été créé précédemment. Donc, je me demande si lu est vraiment thread sûr avec std::map ou il est seulement possible de filer en toute sécurité try{ ...find(..)->second...?

Answer 1

L'idée que l'appel find(...)->second est thread-safe est très dépendante de votre vue de thread-safety. Si vous voulez simplement dire que ça ne va pas tomber, alors tant que personne ne mute le dictionnaire en même temps que vous le lisez, je suppose que vous allez bien.

Cela dit, en effet, peu importe ce que vos exigences de sécurité minimales de fil sont, appeler la méthode operator[] est intrinsèquement pas thread-safe car il peut muter la collection. Si une méthode n'a pas de surcharge const, cela signifie qu'elle peut muter l'objet, donc à moins que la documentation indique que les méthodes sont thread-safe, la méthode est très peu probable.

Là encore, une méthode const pourrait ne pas être thread-safe ainsi, parce que votre objet pourrait dépendre de l'état global non const ou ont mutable champs, de sorte que vous aurez envie d'être très, très prudent si vous utilisez désynchronisé classes comme si elles étaient.

Answer 2

Vous avez raison, operator[] n'est pas "thread-safe" car il peut muter le conteneur. Vous devriez utiliser la méthode find et comparer le résultat à std::map::end pour voir si elle a trouvé l'élément. (Notez également que find a une version const alors que operator[] ne l'est pas).

Comme d'autres l'ont dit, la version de C++ avant C++ 11 n'a pas de notion de thread ou de sécurité de thread. Cependant, vous pouvez vous sentir en sécurité en utilisant find sans synchronisation car il ne change pas le conteneur, donc il ne fait que des opérations de lecture (sauf si vous avez une implémentation bizarre, alors assurez-vous de vérifier les docs). Comme avec la plupart des conteneurs, la lecture à partir de différents threads ne causera aucun dommage, mais l'écriture pourrait le faire.

Answer 3

Les conteneurs de bibliothèque standard n'ont aucune notion de sécurité des threads. Vous devez synchroniser vous-même l'accès en lecture/écriture simultané au conteneur.

try n'a rien à voir avec le multithreading. Il est utilisé pour la gestion des exceptions.

find ne déclenche pas d'exception si la clé n'est pas trouvée. Si la clé n'est pas trouvée, find renvoie l'itérateur end() de la carte.

Answer 4

Si vous êtes sûr à 100% que la carte contient la clé, alors il est techniquement thread-safe si tous les autres threads n'appellent également que des méthodes en lecture seule sur la carte. Notez cependant qu'il n'y a pas de version const de map<k,v>::operator[](const k&).

La bonne façon d'accéder à la carte dans un mode thread-safe est en effet:

map<k,v>::const_iterator match = mymap.find(key); 
if (match != mymap.end()) { 
    // found item. 
} 

Comme indiqué précédemment, cela ne vaut que si tout accès simultané est en lecture seule. Une façon de garantir cela est d'utiliser un readers-writers lock.

Notez qu'en C++ 03, il n'y a aucune mention de threads dans la norme, même si cela n'est pas garanti pour être thread-safe. Assurez-vous de vérifier la documentation de votre implémentation.