Coup de pouce.Fil de discussion a les mutex et les variables de condition. Purement en termes de fonctionnalité, les sémaphores sont donc redondants[*], bien que je ne sais pas si c'est pourquoi ils sont omis.
Les sémaphores sont une base plus primitive, plus simple, et éventuellement mis en œuvre pour être plus rapide, mais n'avez pas la priorité inversion de l'évitement. Ils sont sans doute plus difficile à utiliser que les variables de condition, parce qu'ils exigent que le client afin de s'assurer que le nombre de postes "correspond à" le nombre d'attentes dans certains de manière appropriée. Avec les variables de condition, il est facile de tolérer les parasites des messages, parce que personne ne fait ne fait rien sans en vérifier l'état.
Lire vs écrire des ressources est un leurre de l'OMI, il n'a rien à voir avec la différence entre un mutex et sémaphore. Si vous utilisez un comptage sémaphore, vous pourriez avoir une situation où plusieurs threads simultanément d'accéder à la même ressource, auquel cas il ne serait sans doute d'être un accès en lecture seule. Dans cette situation, vous pourriez être en mesure d'utiliser shared_mutex de coup de pouce.Fil à la place. Mais les sémaphores ne sont pas "pour" protéger les ressources dans la façon dont les mutex sont, ils sont "pour" l'envoi d'un signal à partir d'un thread à l'autre. Il est possible de l' utiliser pour contrôler l'accès à une ressource.
Cela ne signifie pas que toutes les utilisations de sémaphores doivent se rapporter à la lecture seule de ressources. Par exemple, vous pouvez utiliser un sémaphore binaire pour protéger une lecture/écriture de ressources. Peut-être pas une bonne idée, que, depuis un mutex vous donne souvent une meilleure planification de comportement.
[*] Voici à peu près comment mettre en œuvre un comptage à l'aide d'un sémaphore mutex et une variable de condition. Pour mettre en œuvre un sémaphore partagé bien sûr, vous avez besoin d'un partagées mutex/condvar:
struct sem {
mutex m;
condvar cv;
unsigned int count;
};
sem_init(s, value)
mutex_init(s.m);
condvar_init(s.cv);
count = value;
sem_wait(s)
mutex_lock(s.m);
while (s.count <= 0) {
condvar_wait(s.cv, s.m);
}
--s.count;
mutex_unlock(s.m);
sem_post(s)
mutex_lock(s.m);
++s.count;
condvar_broadcast(s.cv)
mutex_unlock(s.m);
Par conséquent, tout ce que vous pouvez faire avec les sémaphores, vous pouvez le faire avec les mutex et les variables de condition. Pas nécessairement par la mise en œuvre d'un sémaphore, cependant.
