Comment Java utilise Synchronized pour réaliser une synchronisation multithread

Raisons de l'utilisation de la synchronisation

1. Des multithreads doivent être utilisés pour accéder aux classes dans le système ;

2 Il y a des variables de classe dans la classe, ou des ressources publiques (comme un fichier externe) sont accessibles dans la méthode de classe. .lire et écrire).

Quel est le contenu verrouillé par le verrouillage de synchronisation ?

Que vous ajoutiez Synchronized avant une méthode ou une variable, cela verrouille un objet de classe. Chaque objet n’est associé qu’à un seul verrou.

Les exemples suivants répertorient les effets de synchronisation dans diverses situations

1 Synchronisé est ajouté à la méthode (méthode synchronisée, instance de classe de verrouillage)

Code Java

public class Demo1 {             public synchronized void m1(){             //...............         }             public void m2(){             //............                 synchronized(this){                 //.........             }                 //........         }     }

L'effet de ces deux méthodes d'écriture est de même, tous verrouillés sont des objets d’instance de classe. S'il existe un objet d'instance de classe : demo = new Demo1() et qu'il y a deux threads : thread1, thread2, tous deux appelant l'objet demo, alors, en même temps, si thread1 appelle demo.m1(), alors thread2 est dans demo.m1() et demo.m2() ne sont pas accessibles pendant ce temps ; parce que thread1 utilise le verrou de l'objet démo, il ne peut pas être alloué à d'autres threads. Cependant, si thread1 appelle demo1.m1(), thread2. appelle demo2 .m1(), peut être exécuté en même temps, car ils appellent différentes instances d'objet de classe Demo1.

2. Synchronisé est ajouté à la variable (bloc synchronisé, instance de classe verrouillée)

Code Java

public class Demo2 {         Object a = new Object();         Object b = new Object();             public void m1(){             //............                 synchronized(a){                 //.........             }                 //........         }             public void m2(){             //............                 synchronized(b){                 //.........             }                 //........         }     }

Dans ce cas, le verrouillage du bloc de code est implémenté et l'objet verrouillé est la variable a ou b ; , a et b sont tous deux non statiques) S'il existe un objet instance de classe : demo = new Demo2() et qu'il y a deux threads : thread1, thread2, appelant tous deux des objets de démonstration, alors, en même temps, si thread1 appelle demo. m1(), alors thread2 peut accéder à demo.m2() dans ce délai ; mais ne peut pas accéder au bloc de synchronisation de demo.m1() car a est verrouillé par thread1.

3. Variables de classe de verrouillage synchronisées, c'est-à-dire des variables statiques (peut être des attributs, peuvent être des méthodes) (objets de classe de verrouillage)

Code Java

public class Demo3 {         static Object o = new Object();             public static synchronized void m1() {             //....         }             public static void m2() {             //...             synchronized (Demo3.class) {                 //.....             }             //.....         }             public static void m3() {             //..........             try {                 synchronized (Class.forName("Demo3")) {                   //............                 }             } catch (ClassNotFoundException ex) {             }             //.............         }             public static void m4() {             //............            synchronized(o){              //........            }             //..........         }     }

Les effets obtenus dans les quatre méthodes ci-dessus sont les mêmes, Le les objets verrouillés sont tous des objets de classe Demo3, pas des objets d'instance de classe, c'est-à-dire que dans les multithreads, les ressources partagées appartiennent à des classes, pas à des objets de classe. Dans ce cas, si thread1 accède à l’une de ces quatre méthodes, aucun autre thread ne peut accéder à ces quatre méthodes en même temps.

4. La ressource commune à plusieurs threads est accessible dans la méthode de classe, et la ressource est variable Dans ce cas, la synchronisation est également requise

Code Java

public class Demo4 {         static String path = "file path";             public void readConfiFile() {             synchronized (path) {                // 读取该path指定的文件。             }             }             public void writeConfiFile() {             synchronized (path) {                 //写信息到该path指定的文件。             }         }     }

Dans ce cas, elle doit être verrouillée Variables de classe. ne peut pas être verrouillé sur les objets d'instance de classe, car il s'agit d'un type de partage de ressources de classe de variables, et non de partage de ressources d'objet d'instance de classe.

Les threads ont leur propre chemin de succès et d'échec. S'ils sont bien utilisés, ils peuvent améliorer les performances, mais s'ils ne sont pas bien utilisés, ils causeront des problèmes sans fin au système.

PS : La synchronisation des threads nécessite beaucoup de surcharge du système, donc lorsque vous l'utilisez, si ce n'est pas nécessaire, essayez de ne pas utiliser la fonction de synchronisation.

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!