Sémaphore vs moniteurs-Quelle est la différence?
Quelles sont les différences majeures entre un Moniteur et a Sémaphore?
7 réponses
Un Moniteur est un objet conçu pour être accessible à partir de plusieurs threads. Les fonctions ou méthodes membres d'un objet monitor imposeront une exclusion mutuelle, de sorte qu'un seul thread peut effectuer une action sur l'objet à un moment donné. Si un thread exécute actuellement une fonction membre de l'objet, tout autre thread qui essaie d'appeler une fonction membre de cet objet devra attendre que le premier soit terminé.
Un sémaphore est un objet de niveau inférieur. Vous pourriez bien utiliser un sémaphore pour implémenter un moniteur. Un sémaphore est essentiellement juste un compteur. Lorsque le compteur est positif, si un thread essaie d'acquérir le sémaphore, il est autorisé et le compteur est décrémenté. Quand un thread est terminé, il libère le sémaphore et incrémente le compteur.
Si le compteur est déjà nul lorsqu'un thread essaie d'acquérir le sémaphore, il doit attendre qu'un autre thread libère le sémaphore. Si plusieurs threads sont en attente thread libère un sémaphore puis l'un d'eux qu'il obtient. Le thread qui libère un sémaphore n'a pas besoin d'être le même thread qui l'a acquis.
Un moniteur est comme une toilette publique. Une seule personne peut entrer à la fois. Ils verrouillent la porte pour empêcher quelqu'un d'autre d'entrer, faire leurs affaires, et puis déverrouiller quand ils partent.
Un sémaphore est comme un lieu de location de vélos. Ils ont un certain nombre de vélos. Si vous essayez de louer un vélo et qu'ils en ont un gratuitement, vous pouvez le prendre, sinon vous faut attendre. Quand quelqu'un retourne son vélo alors quelqu'un d'autre peut le prendre. Si vous avez un vélo, vous pouvez le donner à quelqu'un d'autre pour revenir --- le lieu de location de vélo ne se soucie pas de qui le retourne, tant qu'ils récupèrent leur vélo.
L'explication suivante explique en fait comment wait () et signal () du moniteur diffèrent de P et V du Sémaphore.
Le wait() et signal() opérations sur les variables de condition dans un moniteur semblables à P et V opérations sur le comptage sémaphores.
Une instruction wait {[4] } peut bloquer l'exécution d'un processus, tandis qu'une instruction signal peut entraîner le déblocage d'un autre processus. Cependant, il y a quelques différences entre eux. Lorsqu'un processus exécute une opération P, il ne bloque pas nécessairement ce processus car le sémaphore de comptage peut être supérieur à zéro. En revanche, lorsqu'une instruction wait est exécutée, elle bloque toujours le processus. Lorsqu'une tâche exécute une opération V sur un sémaphore, elle débloque une tâche en attente sur ce sémaphore ou incrémente le compteur de sémaphores s'il n'y a pas de tâche à déverrouiller. D'autre part, si un processus exécute une instruction de signal quand il y a aucun autre processus à débloquer, il n'y a aucun effet sur la variable condition. Une autre différence entre les sémaphores et les moniteurs est que les utilisateurs éveillés par une opération V peuvent reprendre l'exécution sans délai. Au contraire, les utilisateurs éveillés par une opération de signal ne sont redémarrés que lorsque le moniteur est déverrouillé. En outre, une solution de moniteur est plus structurée que celle avec des sémaphores parce que les données et les procédures sont encapsulées dans un seul module et que l'exclusion mutuelle est fournie automatiquement par la mise en œuvre.
Lien: ici pour plus de lecture. Espérons que cela aide.
Une Ligne De Réponse:
Monitor: contrôle un seul thread à la fois peut s'exécuter dans le moniteur. (besoin d'acquérir lock pour exécuter le thread unique)
Sémaphore: un verrou qui protège une ressource partagée. (besoin d'acquérir le verrou pour accéder à la ressource)
Un moniteur est un ensemble de routines multiples qui sont protégées par un verrou d'exclusion mutuelle alors que, un sémaphore est une construction plus simple qu'un moniteur parce que c'est juste un verrou qui protège une ressource partagée – et non un ensemble de routines comme un moniteur. L'application doit acquérir le verrou avant d'utiliser cette ressource partagée protégée par un sémaphore.
Les moniteurs et les sémaphores sont utilisés dans le même but-la synchronisation des threads. Mais, les moniteurs sont plus simples à utiliser que les sémaphores parce qu'ils gèrent tous les détails de l'acquisition et de la libération du verrou.
Une autre différence lors de l'utilisation de sémaphores est que chaque routine accédant à une ressource partagée doit acquérir explicitement un verrou a avant d'utiliser la ressource. Cela peut être facilement oublié lors du codage des routines traitant du multithreading . Les moniteurs, contrairement aux sémaphores, acquièrent automatiquement les verrous nécessaires.
Lorsqu'un sémaphore est utilisé pour protéger une région critique, il n'y a pas de relation directe entre le sémaphore et les données protégées. C'est en partie la raison pour laquelle les sémaphores peuvent être dispersées dans le code, et pourquoi il est facile d'oublier d'appeler attendez ou informer, auquel cas le résultat sera, respectivement, de violer l'exclusion mutuelle ou de verrouiller la ressource de façon permanente.
En revanche, niehter de ces mauvaises choses peuvent se produire avec un moniteur. Un le moniteur est fatigué directement aux données (il encapsule les données) et, parce que les opérations du moniteur sont des actions atomiques, il est impossible d'écrire du code qui peut accéder aux données sans appeler le protocole d'entrée. Le protocole de sortie est appelé automatiquement lorsque l'opération de surveillance est terminée.
Un moniteur a un mécanisme intégré pour la synchronisation de condition sous la forme de variable de condition avant de continuer. Si la condition n'est pas satisfaite, le processus doit attendre jusqu'à ce qu'il est informé d'un changement dans la condition. Lorsqu'un processus attend la synchronisation des conditions, l'implémentation du moniteur prend en charge le problème d'exclusion mutuelle et permet à un autre processus d'accéder au moniteur.
Tiré de l'Open University M362 Unité 3 "Processus D'interaction" matériel de cours.
Sémaphore :
À l'Aide d'un compteur ou un drapeau pour contrôler l'accès à certaines ressources partagées dans un tel système, implique l'utilisation de Sémaphore.
Exemple:
- un comptoir pour permettre à seulement 50 passagers d'acquérir les 50 sièges (ressource partagée) de N'importe quel théâtre/Bus/Train/fun ride/salle de classe. Et pour permettre à un nouveau passager seulement si quelqu'un quitte un siège.
- un drapeau binaire indiquant le statut libre / occupé de N'importe quelle salle de bain.
- feux de circulation sont un bon exemple de drapeaux. Ils contrôlent le flux en régulant le passage des véhicules sur les routes (ressource partagée)
Ne révèlent que l'état actuel de la ressource, aucun compte ou toute autre information sur les objets en attente ou en cours d'exécution sur la ressource.
Moniteur :
Un Monitor synchronise l'accès à un objet en communiquant avec les threads intéressés par l'objet, en leur demandant d'acquérir l'accès ou d'attendre qu'une condition devienne vrai.
Exemple:
- Un père peut agir comme un moniteur pour sa fille, lui permettant de sortir avec un seul gars à la fois.
- un professeur d'école utilisant le bâton pour permettre à un seul enfant de parler dans la classe.
- enfin technique, les transactions (via des threads) sur un objet de Compte synchronisées pour maintenir l'intégrité.