logo

TechCodeview

Synchronisation en Java

La synchronisation en Java est la capacité de contrôler l'accès de plusieurs threads à n'importe quelle ressource partagée.

La synchronisation Java est la meilleure option lorsque nous souhaitons autoriser un seul thread à accéder à la ressource partagée.

Pourquoi utiliser la synchronisation ?

La synchronisation est principalement utilisée pour

  1. Pour éviter les interférences de filetage.
  2. Pour éviter les problèmes de cohérence.

Types de synchronisation

Il existe deux types de synchronisation

  1. Synchronisation des processus
  2. Synchronisation des threads

Ici, nous discuterons uniquement de la synchronisation des threads.

Synchronisation des threads

Il existe deux types de synchronisation de threads, de communication mutuelle exclusive et inter-thread.

  1. Exclusivité mutuelle
    1. Méthode synchronisée.
    2. Bloc synchronisé.
    3. Synchronisation statique.
  2. Coopération (Communication inter-thread en java)

Exclusivité mutuelle

Mutual Exclusive aide à empêcher les threads d'interférer les uns avec les autres lors du partage de données. Cela peut être réalisé en utilisant les trois manières suivantes :

  1. En utilisant la méthode synchronisée
  2. En utilisant le bloc synchronisé
  3. En utilisant la synchronisation statique

Concept de verrouillage en Java

La synchronisation est construite autour d'une entité interne appelée verrou ou moniteur. Chaque objet est associé à un verrou. Par convention, un thread qui a besoin d'un accès cohérent aux champs d'un objet doit acquérir le verrou de l'objet avant d'y accéder, puis libérer le verrou lorsqu'il en a terminé avec eux.

Depuis Java 5, le package java.util.concurrent.locks contient plusieurs implémentations de verrous.

Comprendre le problème sans synchronisation

Dans cet exemple, il n’y a pas de synchronisation, la sortie est donc incohérente. Voyons l'exemple :

TestSynchronisation1.java 

 class Table{ void printTable(int n){//method not synchronized for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization1{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 100 10 200 15 300 20 400 25 500 </pre> <h3>Java Synchronized Method</h3> <p>If you declare any method as synchronized, it is known as synchronized method.</p> <p>Synchronized method is used to lock an object for any shared resource.</p> <p>When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when the thread completes its task.</p> <p> <strong>TestSynchronization2.java</strong> </p> <pre> //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){></pre></=5;i++){>

Méthode synchronisée Java

Si vous déclarez une méthode comme synchronisée, elle est appelée méthode synchronisée.

La méthode synchronisée est utilisée pour verrouiller un objet pour toute ressource partagée.

Lorsqu'un thread appelle une méthode synchronisée, il acquiert automatiquement le verrou pour cet objet et le libère lorsque le thread termine sa tâche.

TestSynchronisation2.java 

 //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){>

Exemple de méthode synchronisée en utilisant une classe anonyme

Dans ce programme, nous avons créé les deux threads en utilisant la classe anonyme, ce qui nécessite moins de codage.

TestSynchronization3.java 

 //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){>