Différence entre sémaphore et moniteur dans un système d'exploitation
Contenu
Semaphore et Monitor permettent aux processus d’accéder aux ressources partagées en exclusion mutuelle. Les deux sont l'outil de synchronisation de processus. Au lieu de cela, ils sont très différents les uns des autres. Où Sémaphore est une variable entière qui ne peut être utilisée que par les opérations wait () et signal () en dehors de l'initialisation. D'autre part, le Moniteur type est un type de données abstrait dont la construction permet d'activer un processus à la fois. Dans cet article, nous discuterons des différences entre sémaphore et moniteur à l'aide du tableau de comparaison présenté ci-dessous.
- Tableau de comparaison
- Définition
- Différences Clés
- Conclusion
Tableau de comparaison
| Base de comparaison | Sémaphore | Moniteur |
|---|---|---|
| De base | Sémaphores est une variable entière S. | Monitor est un type de données abstrait. |
| action | La valeur de Semaphore S indique le nombre de ressources partagées disponibles dans le système. | Le type de moniteur contient des variables partagées et l'ensemble des procédures qui agissent sur la variable partagée. |
| Accès | Lorsqu'un processus accède aux ressources partagées, il effectue l'opération wait () sur S et lorsqu'il libère les ressources partagées, il effectue l'opération signal () sur S. | Lorsqu'un processus souhaite accéder aux variables partagées dans le moniteur, il doit y accéder via les procédures. |
| Variable de condition | Le sémaphore n'a pas de variables de condition. | Le moniteur a des variables de condition. |
Définition de sémaphore
Être un outil de synchronisation de processus, Sémaphore est un variable entière S. Cette variable entière S est initialisée à la nombre de ressources présent dans le système. La valeur du sémaphore S ne peut être modifiée que par deux fonctions attendez() et signal() en dehors de l'initialisation.
Les opérations wait () et signal () modifient la valeur du sémaphore S de manière indivisible. Ce qui signifie que lorsqu'un processus modifie la valeur du sémaphore, aucun autre processus ne peut modifier simultanément la valeur du sémaphore. En outre, le système d'exploitation distingue le sémaphore en deux catégories: comptage de sémaphores et sémaphore binaire.
Dans Compter le sémaphore, la valeur du sémaphore S est initialisée au nombre de ressources présentes dans le système. Lorsqu'un processus souhaite accéder aux ressources partagées, il effectue attendez() opération sur le sémaphore qui décements la valeur du sémaphore par un. Quand il libère la ressource partagée, il effectue une signal() opération sur le sémaphore qui incréments la valeur du sémaphore par un. Lorsque le nombre de sémaphores passe à 0, ça veut dire toutes les ressources sont occupées par les processus. Si un processus doit utiliser une ressource lorsque le nombre de sémaphores est 0, il exécute wait () et obtient bloqué jusqu'à ce qu'un processus utilisant les ressources partagées le libère et que la valeur de sémaphore devienne supérieure à 0.
Dans Sémaphore binaire, la valeur du sémaphore est comprise entre 0 et 1. Elle est similaire au verrouillage mutex, mais mutex est un mécanisme de verrouillage, tandis que le sémaphore est un mécanisme de signalisation. Dans un sémaphore binaire, si un processus souhaite accéder à la ressource, il effectue l'opération wait () sur le sémaphore et décements la valeur de sémaphore de 1 à 0. Lorsque le processus libère la ressource, il effectue une signal() opération sur le sémaphore et incrémente sa valeur à 1. Si la valeur du sémaphore est 0 et qu'un processus souhaite accéder à la ressource, il effectue l'opération wait () et se bloque jusqu'à ce que le processus en cours d'utilisation des ressources libère la ressource.
Définition de moniteur
Pour surmonter les erreurs de synchronisation qui se produisent lors de l’utilisation de sémaphores pour la synchronisation de processus, les chercheurs ont présenté une construction de synchronisation de haut niveau, c’est-à-dire la type de moniteur. Un type de moniteur est un type de données abstrait utilisé pour la synchronisation des processus.
Être un type de moniteur de type de données abstrait contient le variables de données partagées qui doivent être partagés par tous les processus et certains programmeurs définis opérations qui permettent aux processus de s'exécuter en exclusion mutuelle au sein du moniteur. Un processus peut pas directement accéder la variable de données partagée dans le moniteur; le processus doit y accéder par des procédures définis dans le moniteur, qui permettent à un seul processus d’accéder aux variables partagées d’un moniteur à la fois.
La syntaxe de monitor est la suivante:
monitor monitor_name {// déclaration de variable partagée procédure P1 (...) {} procédure P2 (...) {} procédure Pn (...) {} code d'initialisation (...) {}}
Un moniteur est une construction telle qu'un seul processus est actif à la fois dans le moniteur. Si un autre processus tente d'accéder à la variable partagée dans le moniteur, celle-ci est bloquée et est alignée dans la file d'attente pour obtenir l'accès aux données partagées lorsque le processus d'accès précédent la libère.
Variables conditionnelles ont été introduits pour un mécanisme de synchronisation supplémentaire. La variable conditionnelle permet à un processus d'attendre à l'intérieur du moniteur et permet à un processus en attente de reprendre immédiatement lorsque l'autre processus libère les ressources.
le variable conditionnelle ne peut invoquer que deux opérations attendez() et signal() Où si un processus P invoque une attente () opération, il est suspendu dans le moniteur jusqu'à ce qu'un autre processus Q invoke signal () opération, c'est-à-dire qu'une opération signal () appelée par un processus reprend le processus suspendu.
- La différence fondamentale entre sémaphore et moniteur est que le sémaphore est un variable entière S qui indiquent le nombre de ressources disponibles dans le système alors que le moniteur est le type de données abstrait qui ne permet qu’un seul processus à exécuter dans une section critique à la fois.
- La valeur de sémaphore peut être modifiée par attendez() et signal() opération seulement. D'autre part, un moniteur possède les variables partagées et les procédures uniquement via lesquelles les processus peuvent accéder aux variables partagées.
- En sémaphore, lorsqu'un processus souhaite accéder à des ressources partagées qu'il effectue attendez() opération et bloque les ressources et quand il libère les ressources qu'il effectue signal() opération. Dans les analyses lorsqu'un processus doit accéder à des ressources partagées, il doit y accéder via les procédures de l'analyse.
- Le type de moniteur a variables de condition quel sémaphore n'a pas.
Conclusion:
Les moniteurs sont faciles à implémenter par rapport aux sémaphores, et il y a peu de risque d'erreur d'erreur par rapport aux sémaphores.
