Comment comprendre la synchronisation multithread en Java

1. Sujets du premier arrivé, premier servi

Prenons un sale exemple : la salle de bain d'un restaurant est très petite et peut à peine accueillir une seule personne. Afin de garantir qu'il n'y ait aucune interférence, les personnes qui utilisent les toilettes doivent verrouiller la porte lorsqu'elles entrent dans la salle de bain. Nous pouvons considérer la salle de bain comme une ressource partagée, et les nombreuses personnes qui ont besoin d’aller aux toilettes peuvent être considérées comme de multiples fils. Si la salle de bain est actuellement occupée, d'autres doivent attendre que la personne ait fini d'utiliser les toilettes, ouvre la porte et sorte. C'est comme lorsque plusieurs threads partagent une ressource, ils doivent être priorisés selon le principe du premier arrivé, premier servi.

Quelqu’un a dit : Que se passerait-il si je n’avais pas cette porte ? Laissez deux fils s'affronter. Celui qui gagne en premier peut travailler en premier. Mais nous savons que s'il n'y a pas de porte vers les toilettes et que les gens se précipitent ensemble vers les toilettes, il y aura inévitablement des conflits, les étapes normales d'utilisation des toilettes seront perturbées et des résultats inattendus risquent de se produire, par exemple, certaines personnes. Vous pourriez être obligé d'appliquer de l'engrais au mauvais endroit...

C'est précisément grâce à cette porte que toute personne qui entre seule dans les toilettes peut terminer son processus de toilette en douceur sans être dérangée ni même avoir d'autres résultats. Cela signifie que lorsque vous allez aux toilettes, vous devez procéder selon le principe du premier arrivé, premier servi.

Donc, dans un programme Java multithread, lorsque plusieurs threads se disputent la même ressource, comment pouvons-nous nous assurer qu'ils ne « se battront » pas ? Certains disent qu’il utilise un mécanisme de synchronisation. C'est vrai, l'exemple ci-dessus est un cas typique de synchronisation. Une fois que le premier commence à aller aux toilettes, le second doit attendre que le premier ait fini avant de pouvoir commencer son processus d'aller aux toilettes. Une fois qu'un thread entre dans un certain processus, il doit attendre un retour normal et quitter le processus avant que le thread suivant puisse démarrer le processus.

La chose la plus importante ici est la porte de la salle de bain. En fait, la porte de la salle de bain joue le rôle d'une serrure à ressources. Tant que la personne qui utilise les toilettes verrouille la porte, cela équivaut à obtenir la serrure, et lorsqu'elle ouvre la serrure et sort, cela équivaut à libérer la serrure. verrouillage.

En d'autres termes, le mécanisme de synchronisation des threads multithread est en réalité contrôlé par le concept de verrous. Alors, comment les verrous sont-ils reflétés dans les programmes Java ?

Regardons le concept de verrous du point de vue de la JVM :

Dans l'environnement d'exécution du programme Java, la JVM doit coordonner les données partagées par deux types de threads :

1) Variables d'instance enregistrées dans le tas

2) Variables de classe enregistrées dans la zone méthode

Ces deux types de données sont partagés par tous les threads. (Le programme n'a pas besoin de coordonner les données stockées dans la pile Java. Parce que ces données sont privées du thread qui possède la pile.)

Dans la machine virtuelle Java, chaque objet et classe est logiquement associé à un moniteur associé.

Pour les objets, le moniteur associé protège les variables d'instance de l'objet.

Pour les classes, les moniteurs protègent les variables de classe de la classe. (Si un objet n'a pas de variables d'instance ou si une classe n'a pas de variables, le moniteur associé ne surveillera rien.)

Afin de réaliser les capacités de surveillance exclusives du moniteur, la machine virtuelle Java associe un verrou à chaque objet et classe. Représente un privilège qu'un seul thread est autorisé à avoir à tout moment. Les threads ne nécessitent pas de verrous pour accéder aux variables d'instance ou aux variables de classe.

Mais si un thread acquiert le verrou, aucun autre thread ne peut acquérir le verrou sur les mêmes données avant de libérer le verrou. (Verrouiller un objet consiste à obtenir le moniteur associé à l'objet)

Les verrous de classe sont en fait implémentés à l'aide de verrous d'objet. Lorsque la machine virtuelle charge un fichier de classe, elle crée une instance de la classe java.lang.Class. Lorsqu'un objet est verrouillé, ce qui est réellement verrouillé est l'objet Class de cette classe.

Un fil de discussion peut verrouiller le même objet plusieurs fois. Pour chaque objet, la machine virtuelle Java maintient un compteur de verrous. Chaque fois que le thread obtient l'objet, le compteur est incrémenté de 1. Chaque fois qu'il est relâché, le compteur est décrémenté de 1. Lorsque la valeur du compteur atteint 0, le verrou est activé. est complètement libéré.

Les programmeurs Java n'ont pas besoin de se verrouiller, les verrous d'objets sont utilisés en interne par la machine virtuelle Java.

Dans un programme Java, il vous suffit d'utiliser un bloc synchronisé ou une méthode synchronisée pour marquer une zone de surveillance. Chaque fois que vous entrez dans une zone de surveillance, la machine virtuelle Java verrouille automatiquement l'objet ou la classe.

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!