Le contenu de cet article porte sur ce que signifie Monitor ? L'introduction de Monitor en Java a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer, j'espère que cela vous sera utile.

Le concept de moniteur

Monitor en anglais est aussi souvent traduit par « moniteur ». Monitor, qu'il soit traduit par « moniteur » ou « moniteur », est une comparaison obscure, à travers le chinois traduit, il est impossible d'obtenir une description intuitive du moniteur.
Dans cet article « Primitives de synchronisation du système d'exploitation », certaines primitives de synchronisation prises en charge par le système d'exploitation face à la synchronisation entre processus/threads sont présentées, parmi lesquelles le sémaphore et le mutex mutex sont les primitives de synchronisation les plus populaires.
Lors de l'utilisation d'un mutex de base pour le contrôle de concurrence, les programmeurs doivent être très prudents pour contrôler les opérations de descente et de montée du mutex, sinon il est facile de provoquer des problèmes tels qu'un blocage. Afin de faciliter l'écriture de programmes simultanés corrects, un moniteur primitif de synchronisation de niveau supérieur est proposé, basé sur mutex et sémaphore. Cependant, il convient de noter que le système d'exploitation lui-même ne prend pas en charge le mécanisme de surveillance. appartient à la catégorie des langages de programmation. Lorsque vous souhaitez utiliser Monitor, vérifiez d'abord si le langage lui-même prend en charge la primitive Monitor. Par exemple, le langage C ne prend pas en charge Monitor et le langage Java prend en charge Monitor.
Le mode général d'implémentation du moniteur est que le langage de programmation fournit du sucre syntaxique dans la syntaxe, et la façon d'implémenter le mécanisme du moniteur est le travail du compilateur.

La caractéristique importante du moniteur est qu'un seul processus/thread peut entrer dans la section critique définie dans le moniteur en même temps, ce qui permet au moniteur d'obtenir un effet d'exclusion mutuelle. Mais il ne suffit pas d'avoir une exclusion mutuelle. Les processus/threads qui ne peuvent pas accéder à la section critique du moniteur doivent être bloqués et réveillés si nécessaire. Évidemment, en tant qu'outil de synchronisation, Monitor devrait également fournir un tel mécanisme pour gérer l'état des processus/threads. Pensez à la raison pour laquelle nous pensons que les sémaphores et les mutex sont sujets aux erreurs en programmation, car nous devons manipuler personnellement les variables et bloquer et réactiver les processus/threads. La raison pour laquelle le mécanisme du moniteur est appelé « primitive de niveau supérieur » est qu'il doit inévitablement protéger ces mécanismes de l'extérieur et les mettre en œuvre en interne, afin que les personnes qui utilisent le moniteur voient une interface simple et facile à utiliser. .

Éléments de base du moniteur

Le mécanisme du moniteur nécessite la coopération de plusieurs éléments, à savoir :

1. Section critique

2. Surveiller l'objet et verrouiller

3. Variables de condition et opérations d'attente et de signal définies sur l'objet surveillé.

L'objectif principal de l'utilisation du mécanisme de surveillance est d'exclure mutuellement l'entrée dans la section critique. Afin de bloquer les processus/threads qui ne peuvent pas entrer dans la section critique, un objet moniteur est nécessaire pour. assist.Ce moniteur Il y aura des structures de données correspondantes à l'intérieur de l'objet, telles que des listes, pour sauvegarder les threads bloqués en même temps, car le mécanisme du moniteur est essentiellement basé sur le mutex primitif de base, l'objet moniteur doit également maintenir un mutex- verrouillage basé.
De plus, afin de pouvoir bloquer et réveiller le processus/thread au moment approprié, une variable de condition doit être introduite. Cette variable de condition est utilisée pour déterminer quand est cette condition. peut provenir de la logique du code du programme, ou Cela peut être à l'intérieur de l'objet moniteur. Bref, le programmeur a une grande autonomie dans la définition des variables de condition. Cependant, étant donné que l'objet moniteur utilise une structure de données interne pour enregistrer la file d'attente bloquée, il doit également fournir deux API externes pour permettre au thread d'entrer dans l'état bloqué et de se réveiller plus tard, à savoir attendre et notifier.

Le langage Java prend en charge le moniteur

Monitor est une primitive de haut niveau proposée par le système d'exploitation, mais son mode d'implémentation spécifique peut être différent selon les langages de programmation. Ce qui suit utilise le moniteur Java comme exemple pour expliquer comment le moniteur est implémenté en Java.

Délimitation des sections critiques

En Java, le mot-clé synchronisé peut être utilisé pour modifier les méthodes d'instance, les méthodes de classe et les blocs de code, comme indiqué ci-dessous :

/**
 * @author beanlam
 * @version 1.0
 * @date 2018/9/12
 */
public class Monitor {

    private Object ANOTHER_LOCK = new Object();

    private synchronized void fun1() {
    }

    public static synchronized void fun2() {
    }

    public void fun3() {
        synchronized (this) {
        }
    }

    public void fun4() {
        synchronized (ANOTHER_LOCK) {
        }
    }
}

Le les méthodes et les blocs de code modifiés par le mot-clé synchronisé sont les sections critiques du mécanisme de surveillance.

surveiller l'objet

On peut constater que lorsque vous utilisez le mot-clé synchronisé ci-dessus, vous devez souvent spécifier un objet à lui associer, tel que synchronisé(ceci) ou synchronisé(ANOTHER_LOCK Si synchronisé). modifie S'il s'agit d'une méthode d'instance, alors son objet associé est en fait this. S'il s'agit d'une méthode de classe, alors son objet associé est this.class. En bref, synchronisé doit être associé à un objet, et cet objet est l'objet moniteur.
Dans le mécanisme de surveillance, l'objet moniteur joue le rôle de maintien du mutex et de définition de l'API d'attente/signal pour gérer le blocage et le réveil des threads.
La classe java.lang.Object dans le langage Java est l'objet qui répond à cette exigence. Tout objet Java peut être utilisé comme objet de surveillance du mécanisme de surveillance.
Les objets Java sont stockés en mémoire et sont divisés en trois parties, à savoir l'en-tête de l'objet, les données d'instance et le remplissage d'alignement. Dans son en-tête d'objet, l'identifiant du verrou est enregistré en même temps, définit la classe java.lang.Object ; Méthodes wait(), notify(), notifyAll(), l'implémentation spécifique de ces méthodes repose sur une implémentation appelée mode ObjectMonitor, qui est un ensemble de mécanismes implémentés au sein de la JVM basé sur C++. Le principe de base est le suivant :

Lorsqu'un thread doit acquérir le verrou d'un objet, il sera placé dans le EntrySet pour attendre. Si le thread acquiert le verrou, il le fera. devenir propriétaire de la serrure actuelle. Si, selon la logique du programme, un thread qui a acquis le verrou ne dispose pas de certaines conditions externes et ne peut pas continuer (par exemple, le producteur constate que la file d'attente est pleine ou le consommateur constate que la file d'attente est vide), alors le thread peut transférer le lock en appelant la méthode wait. Release et entrez l'attente définie pour bloquer et attendre. À ce moment, d'autres threads ont la possibilité d'obtenir le verrou et de faire d'autres choses, de sorte que les conditions externes qui n'ont pas été établies auparavant soient établies, donc. que les threads précédemment bloqués peuvent réintégrer le EntrySet pour concourir pour le verrou. Cette condition externe est appelée variable de condition dans le mécanisme de surveillance.

mot-clé synchronisé

Le mot-clé synchronisé est un outil important utilisé par Java au niveau syntaxe pour permettre aux développeurs de synchroniser facilement les multi-threads. Pour saisir une méthode ou un bloc de code modifié par une méthode synchronisée, le verrou d'objet de l'objet lié au mot-clé synchronisé sera d'abord obtenu. Ce verrou empêche également les autres threads d'entrer dans d'autres zones de code synchronisé liées à ce verrou.

De nombreux articles et informations sur Internet, lors de l'analyse du principe de synchronisation, disent essentiellement que la synchronisation est mise en œuvre sur la base du mécanisme de surveillance, mais peu d'articles le précisent, et ils sont tous vagues.

En référence aux éléments de base de Monitor mentionnés précédemment, si la synchronisation est implémentée sur la base du mécanisme du moniteur, quels sont les éléments correspondants ?
Il doit avoir une section critique. Nous pouvons ici considérer la section critique comme l'opération P ou V sur le mutex d'en-tête de l'objet. Il s'agit d'une section critique
Alors à laquelle correspond l'objet moniteur ? mutex ? En bref, le véritable objet moniteur est introuvable.
Je pense donc que l'affirmation « la synchronisation est implémentée sur la base du mécanisme de surveillance » est incorrecte et ambiguë.
Le mécanisme de surveillance fourni par Java est en fait formé par la coopération d'éléments Objet, synchronisés et autres. Même les variables de condition externes sont également un composant. L'ObjectMonitor sous-jacent de la JVM n'est qu'un mode commun utilisé pour aider à la mise en œuvre du mécanisme de surveillance, mais la plupart des articles considèrent directement ObjectMonitor comme le mécanisme de surveillance.
Je pense que cela doit être compris de cette façon : la prise en charge des moniteurs par Java est fournie aux développeurs selon la granularité du mécanisme, c'est-à-dire que les développeurs doivent utiliser le mot-clé synchronisé en combinaison avec des éléments tels que wait/notify d'Object. Il a déclaré avoir utilisé le mécanisme de surveillance pour résoudre un problème entre producteur et consommateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!