Au niveau théorique, ils ne sont pas différents sémantiquement. Vous pouvez implémenter un mutex en utilisant des sémaphores ou vice versa (voir ici pour un exemple). En pratique, la mise en œuvre est différente et ils offrent des services légèrement différents.
La différence pratique (en termes de services système qui les entourent) est que la mise en œuvre d'un mutex vise à être un mécanisme de synchronisation plus léger. En langage oracle, les mutex sont appelés verrous et les sémaphores sont appelés attentes .
Au niveau le plus bas, ils utilisent une sorte de test atomique et de mécanisme de réglage . Cela lit la valeur actuelle d'un emplacement mémoire, calcule une sorte de conditionnel et écrit une valeur à cet emplacement dans une seule instruction qui ne peut pas être interrompue . Cela signifie que vous pouvez acquérir un mutex et tester pour voir si quelqu'un d'autre l'avait avant vous.
Une implémentation de mutex typique a un processus ou un thread exécutant l'instruction test-and-set et évaluant si quelque chose d'autre a défini le mutex. Un point clé ici est qu'il n'y a pas d'interaction avec l' ordonnanceur , nous n'avons donc aucune idée (et ne nous en soucions pas) qui a défini le verrou. Ensuite, nous abandonnons notre tranche de temps et la réessayons lorsque la tâche est reprogrammée ou exécutons un verrou rotatif . Un verrou tournant est un algorithme comme:
Count down from 5000:
i. Execute the test-and-set instruction
ii. If the mutex is clear, we have acquired it in the previous instruction
so we can exit the loop
iii. When we get to zero, give up our time slice.
Lorsque nous avons terminé d'exécuter notre code protégé (connu sous le nom de section critique ), nous mettons simplement la valeur mutex à zéro ou tout ce qui signifie «effacer». Si plusieurs tâches tentent d'acquérir le mutex, la prochaine tâche programmée après la libération du mutex aura accès à la ressource. En règle générale, vous utiliseriez des mutex pour contrôler une ressource synchronisée où l'accès exclusif n'est nécessaire que pour de très courtes périodes de temps, normalement pour effectuer une mise à jour d'une structure de données partagée.
Un sémaphore est une structure de données synchronisée (utilisant généralement un mutex) qui a un nombre et certains wrappers d'appel système qui interagissent avec le planificateur dans un peu plus de profondeur que les bibliothèques mutex. Les sémaphores sont incrémentés et décrémentés et utilisés pour bloquer les tâches jusqu'à ce que quelque chose d'autre soit prêt. Voir Problème producteur / consommateur pour un exemple simple de cela. Les sémaphores sont initialisés à une certaine valeur - un sémaphore binaire est juste un cas spécial où le sémaphore est initialisé à 1. La publication dans un sémaphore a pour effet de réveiller un processus d'attente.
Un algorithme de sémaphore de base ressemble à:
(somewhere in the program startup)
Initialise the semaphore to its start-up value.
Acquiring a semaphore
i. (synchronised) Attempt to decrement the semaphore value
ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice.
Posting a semaphore
i. (synchronised) Increment the semaphore value
ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable.
iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting.
Dans le cas d'un sémaphore binaire, la principale différence pratique entre les deux est la nature des services du système entourant la structure de données réelle.
EDIT: Comme evan l'a souligné à juste titre, les verrous tournants ralentiront une machine à processeur unique. Vous utiliseriez uniquement un verrou tournant sur une boîte multiprocesseur car sur un seul processeur, le processus contenant le mutex ne le réinitialisera jamais pendant qu'une autre tâche est en cours d'exécution. Les verrous tournants ne sont utiles que sur les architectures multiprocesseurs.