Bonjour,
 
Voila, j'ai une appli qui tourne avec plusieurs threads.
 
Ces differents threads se partagent des données.
 
Tous les threads accedent en lecture à ces données.
Tous les threads, sauf 1 qui est spécial accedent aussi en ecriture.
 
Voila mon probleme :
 
Le thread qui n'accedent qu'en lecture est le moteur principal du logiciel, il doit donc pouvoir s'executer le plus rapidement possible.
 
Les autres threads peuvent se permettre d'attendre un peu, c'est pas genant.
 
Je pense faire un truc du genre :
 
Acces en lecture :
- tant qu'une ecriture n'est pas en attente, on autorise la lecture.
- pendant la lecture, on interdit l'ecriture.
 
Acces en ecriture :
- on fait une demande d'ecriture (qui va bloquer les fonctions de lecture)
- on attend que toutes les lectures en cours soient terminées
- on ecrit
- on debloque la lecture
 
Vu que les performances du thread principal (que lecture) sont essentielles dans ce projet, quel objet de synchronisation utiliser ?
 
J'ai pensé à "Slim Reader/Writer (SRW) Locks" : http://msdn2.microsoft.com/en-us/library/aa904937.aspx
 
D'après la doc, c'est le plus rapide, mais je ne sais pas trop comment l'utiliser...
 
Des idées ?

Le plus rapide est vraisemblablement de ne pas utiliser de lock du tout (google: lockless) et de mettre à jour en garantissant la cohérence. Je dis vraisemblablement parce que dans certaine situations - surtout si on veut garantir l'équité (google: fairness) - les locks peuvent être plus efficaces.
En fait la question est trop vague pour décider: quid des cas de famine pour l'écriture (google: contention, starvation...)... etc...
 
PS: mutex, sémaphore c'est du pareil au même dans ce contexte.