Java Multithreading - Blocs synchrones
Le blocage synchronisé Java est utilisé pour marquer la méthode ou le bloc de code qui est synchronisé. Les blocs de synchronisation Java sont utilisés pour éviter la concurrence. Cet article présente le contenu suivant:
Mots-clés synchronisés Java (synchronisés)
Les blocs synchronisés en Java sont marqués synchronisés. Les blocs de synchronisation sont synchronisés sur un objet en Java. Tous les blocs de synchronisation synchronisés sur un objet ne peuvent être entrés que par un seul thread et effectuer des opérations en même temps. Tous les autres threads en attente pour entrer le bloc de synchronisation seront bloqués jusqu'à ce que les threads du bloc de synchronisation soient exécutés.
Il existe quatre blocs de synchronisation différents:
Les blocs de synchronisation ci-dessus sont tous synchronisés sur différents objets. Quel bloc de synchronisation est réellement nécessaire dépend de la situation spécifique.
Synchronisation de la méthode d'instance
Voici un exemple de méthode synchronisée:
public synchronisé void add (int value) {this.Count + = valeur; }
Synchronisation de la méthode statique
La synchronisation de la méthode statique est la même que la méthode de synchronisation de la méthode d'instance, et le mot-clé synchronisé est également utilisé. La synchronisation de la méthode statique Java est la suivante:
public static synchronisé void add (int value) {count + = valeur; }De même, le mot-clé synchronisé ici indique à Java que cette méthode est synchronisée.
La synchronisation des méthodes statiques fait référence à la synchronisation sur l'objet de classe où se trouve la méthode. Étant donné qu'une classe ne peut correspondre qu'à un seul objet de classe dans une machine virtuelle Java, un seul thread est autorisé à exécuter des méthodes de synchronisation statiques dans la même classe.
Pour les méthodes de synchronisation statique dans différentes classes, un thread peut exécuter des méthodes de synchronisation statiques dans chaque classe sans attendre. Quelle que soit la méthode de synchronisation statique dans la classe appelée, une classe ne peut être exécutée que par un seul thread en même temps.
Blocs synchrones dans les méthodes d'instance
Parfois, vous n'avez pas besoin de synchroniser toute la méthode, mais de synchroniser une partie de la méthode. Java peut synchroniser une partie d'une méthode.
Un exemple de bloc de synchronisation dans une méthode Java asynchrone est illustré ci-dessous:
public void add (int value) {synchronisé (this) {this.Count + = valeur; }}Exemples Utilisez le constructeur de blocs synchrones Java pour marquer un morceau de code synchronisé. Ce code est le même que la méthode de synchronisation lors de l'exécution.
Notez que le constructeur de blocs synchrones Java renferme l'objet entre parenthèses. Dans l'exemple ci-dessus, "ceci" est utilisé, c'est-à-dire l'instance elle-même qui appelle la méthode ADD. Les objets enfermés entre parenthèses dans le constructeur de synchronisation sont appelés objets de moniteur. Le code ci-dessus utilise la synchronisation des objets Monitor et la méthode d'instance synchrone utilise l'instance de la méthode d'appel elle-même comme objet Monitor.
Un seul thread peut s'exécuter dans des méthodes Java synchronisées avec le même objet Monitor à la fois.
Les deux exemples suivants synchronisent l'objet d'instance qu'ils appellent, ils sont donc équivalents dans l'effet d'exécution synchronisé.
classe publique MyClass {public synchronisé void log1 (chaîne msg1, chaîne msg2) {log.writeln (msg1); Log.Writeln (MSG2); } public void log2 (string msg1, string msg2) {synchronisé (this) {log.writeln (msg1); Log.Writeln (MSG2); }}}Dans l'exemple ci-dessus, un seul thread peut être exécuté dans l'un des deux blocs de synchronisation à la fois.
Si le deuxième bloc de synchronisation n'est pas synchronisé sur cet objet d'instance, les deux méthodes peuvent être exécutées simultanément par le thread.
Blocs synchrones dans les méthodes statiques
Semblable à ce qui précède, les exemples suivants sont des exemples de deux méthodes statiques Synchronisation. Ces méthodes sont synchronisées sur l'objet de classe auquel appartient la méthode.
classe publique myClass {public static synchronisé void log1 (String msg1, string msg2) {log.writeln (msg1); Log.Writeln (MSG2); } public static void log2 (string msg1, string msg2) {synchronisé (myClass.class) {log.writeln (msg1); Log.Writeln (MSG2); }}}Ces deux méthodes ne permettent pas d'accès par les threads en même temps.
Si le deuxième bloc de synchronisation n'est pas synchronisé sur l'objet MyClass.class. Ensuite, ces deux méthodes sont accessibles par les threads en même temps.
Instance de synchronisation Java
Dans l'exemple suivant, deux threads sont démarrés, appelant tous deux la méthode ADD de la même instance de la classe de compteur. Étant donné que la synchronisation est sur l'instance à laquelle appartient la méthode, un seul thread peut accéder à la méthode en même temps.
classe publique Counter {Long Count = 0; public synchronisé void add (valeur longue) {this.Count + = valeur; }} public Class Couterthread étend Thread {Protected Counter Counter = NULL; Public Counthread (compteur de compteur) {this.Count = compter; } public void run () {for (int i = 0; i <10; i ++) {compter.add (i); }}} Exemple de classe publique {public static void main (String [] args) {compteur compteur = new Counter (); Thread threada = new Counthread (compteur); Thread ThreadB = new Counthread (compteur); threada.start (); ThreadB.Start (); }}Deux fils ont été créés. Leur constructeur fait référence au même compteur. La méthode compteur.add est synchronisée sur une instance car la méthode ADD est une méthode d'instance et est marquée avec le mot-clé synchronisé. Par conséquent, un seul thread est autorisé à appeler la méthode à la fois. Un autre thread doit attendre que le premier thread quitte la méthode Add () avant de continuer à exécuter la méthode.
Si deux threads se réfèrent à deux instances de compteur différentes, ils peuvent appeler la méthode Add () en même temps. Ces méthodes appellent différents objets, donc ces méthodes sont synchronisées sur différents objets. Ces appels de méthode ne seront pas bloqués. Comme indiqué dans l'exemple suivant:
Exemple de classe publique {public static void main (String [] args) {compter contrea = new Counter (); Counter CounterB = new Counter (); Thread threada = new Counthread (Coughta); Thread ThreadB = new Counthread (CounterB); threada.start (); ThreadB.Start (); }}Notez que ces deux threads, Threada et Threadb, ne font plus référence à la même instance de compteur. Les méthodes ADD de CounterA et CounterB sont synchronisées sur l'objet à laquelle ils appartiennent. L'appel de la méthode ADD de Countera ne bloquera pas l'appel à la méthode ADD de CounterB.
Ce qui précède est une explication des connaissances des blocs de synchronisation multithreads Java. Nous continuerons d'ajouter des informations pertinentes à l'avenir. Merci pour votre soutien à ce site!