Bloc synchronisé en Java

En Java, un bloc synchronisé permet d'effectuer la synchronisation sur n'importe quelle ressource particulière de la fonction ou de la méthode. S'il y a 100 lignes de code (LOC) et que la synchronisation doit être effectuée sur seulement 10 lignes, alors un bloc synchronisé peut être utilisé. Synchronisé peut être utilisé comme mot-clé, méthode et blocs. Dans ce tutoriel, nous discuterons en détail du bloc synchronisé.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

La syntaxe du bloc synchronisé est la suivante :

Synchronized( lo)
{
//statements that have to be synchronized
}

Ici, voilà l'objet verrou

Comment fonctionne le bloc synchronisé en Java ?

Comme déjà évoqué, le bloc Synchronisé aide à effectuer la synchronisation sur n'importe quelle ressource particulière de la fonction ou de la méthode. Lorsqu'un thread a besoin d'exécuter des lignes synchronisées à l'intérieur du bloc synchronisé, il est obligatoire d' acquérir le verrou sur le moniteur de l'objet verrou lo mentionné dans la syntaxe ci-dessus. À la fois, un seul thread peut acquérir le moniteur de l’objet verrouillé. Chaque thread doit attendre que le thread qui détient actuellement le verrou termine l'exécution et le libère.

De même, le mot-clé synchronisé garantit qu'à la fois, un seul thread exécutera les lignes de code dans un bloc synchronisé, ce qui empêche plus d'un thread de corrompre les données partagées dans le bloc.

Supposons qu'une méthode se compose de 500 LOC (lignes de code), mais qu'il n'existe que 20 lignes de code contenant une section critique (CS) de code. Autrement dit, ces 20 lignes peuvent modifier ou changer l’état de l’objet. Ainsi, la synchronisation peut être effectuée sur ces 20 lignes de fonction de code pour éviter toute altération de l'état de l'objet et garantir que les autres threads exécutent les 480 autres lignes de la méthode particulière sans aucune interruption.

Exemples de bloc synchronisé en Java

Voyons maintenant quelques exemples de programmes sur le bloc synchronisé en Java.

Exemple n°1

Programme Java pour implémenter le bloc synchronisé

Code :

class Testsmple{
void printTestsmple(int n)
{
//start of synchronized block
synchronized(this)
{
System.out.println("The output of synchronized block is: ");
for( int i=1 ; i<=4 ; i++ )
{
System.out.println(n*i);
//exception handling
try
{
Thread.sleep(500);
}
catch(Exception exc)
{
System.out.println(exc) ;
}
}
}
} //end
}
class T1 extends Thread
{
Testsmple t;
T1(Testsmple t)
{
this.t=t;
}
public void run()
{
t.printTestsmple(10);
}
}
class T2 extends Thread
{
Testsmple t;
T2(Testsmple t)
{
this.t=t;
}
public void run()
{
t.printTestsmple(200);
}
}
public class SyncBlockExample
{
public static void main(String args[])
{
// create only one object
Testsmple ob = new Testsmple();
//objects of threads
T1 t1=new T1(ob);
T2 t2=new T2(ob);
//start the threads t1 and t2
t1.start();
t2.start();
}  }

Sortie :

Dans ce programme, deux threads t1 et t2 sont utilisés, chacun d'eux ayant une méthode printTestsmple qui appelle la méthode synchronisée. L'entrée du thread 1 pour printTestsmple est 10 et l'entrée du thread 2 est 200. Dans le résultat, on peut voir que la sortie du bloc synchronisé du premier thread est 10, 20, 30, 40. En même temps, le résultat du bloc synchronisé du thread 2 est 200, 400, 600, 800. De plus, il y a une ligne « La sortie du bloc synchronisé est : » qui est imprimée entre le résultat de chaque thread.

Exemple n°2

Programme Java pour implémenter des blocs synchronisés à l'aide de l'utilisation d'une classe anonyme.

Code :

class Testsmple{
void printTestsmple(int n)
{
//start of synchronized block
synchronized(this)
{
System.out.println("The output of synchronized block is: ");
for( int i=1 ; i<=4 ; i++ )
{
System.out.println(n*i);
//exception handling
try
{
Thread.sleep(500);
}
catch(Exception exc)
{
System.out.println(exc) ;
}
}
}
} //end
}
public class SyncBlockExample
{
//main method
public static void main(String args[])
{
//create only one object
final Testsmple obj = new Testsmple() ;
//create thread th1
Thread th1=new Thread()
{
public void run()
{
obj.printTestsmple(10) ;
}
}
;
//create thread th2
Thread th2=new Thread()
{
public void run()
{
obj.printTestsmple(200);
}
} ;
th1.start() ;
th2.start() ;
}}

Sortie :

Dans ce programme également, deux threads t1 et t2 sont utilisés, chacun d'eux ayant une méthode printTestsmple qui appelle la méthode synchronisée. L'entrée du thread 1 pour printTestsmple est 10 et l'entrée du thread 2 est 200. Dans le résultat, on peut voir que la sortie du bloc synchronisé du premier thread est 10, 20, 30, 40. En même temps, le résultat du bloc synchronisé du thread 2 est 200, 400, 600, 800. De plus, il y a une ligne « La sortie du bloc synchronisé est : » qui est imprimée entre le résultat de chaque thread. La seule différence est la présence d'une classe anonyme dans ce programme.

Exemple #3

Programme Java pour implémenter le bloc synchronisé.

import java.util.*;
class ABC
{
String nm = "";
public int cnt = 0;
public void samplename(String stringexample, List<String>li)
{
// In order to change the name at a time, only 1 thread is permitted
synchronized(this)
{
nm = stringexample;
cnt++;
}
li.add(stringexample);
}
}
public class SyncBlockExample
{
//main method
public static void main (String[] args)
{
//create an object for the class ABC
ABC obj = new ABC();
//create a list
List<String>li = new ArrayList<String>();
//call the method using the object created
obj.samplename("Anna Sam", li);
System.out.println(obj.nm);
}
}

Sortie :

Dans ce programme, une classe ABC est créée avec une méthode synchronisée à l'intérieur du nom d'échantillon de méthode. Une chaîne « Anna Sam » est transmise en entrée pour appeler la méthode samplename. Lors de l'exécution du code, la chaîne « Anna Sam » est imprimée.

Avantages

Certains des avantages sont indiqués ci-dessous :

• Une amélioration des performances peut être effectuée si la portée de la synchronisation est limitée.
• Synchronisez de petits blocs de code pour réduire le coût de calcul.
• Flexible pour utiliser d'autres objets comme verrous.
• Java étant un langage de programmation multithread, il est préférable de parvenir à une exclusion mutuelle sur les ressources partagées.

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!