logo

TechCodeview

Sincronizzazione in Java

La sincronizzazione in Java è la capacità di controllare l'accesso di più thread a qualsiasi risorsa condivisa.

La sincronizzazione Java è l'opzione migliore quando vogliamo consentire a un solo thread di accedere alla risorsa condivisa.

Perché utilizzare la sincronizzazione?

La sincronizzazione viene utilizzata principalmente per

  1. Per evitare interferenze con il filo.
  2. Per evitare problemi di coerenza.

Tipi di sincronizzazione

Esistono due tipi di sincronizzazione

  1. Sincronizzazione dei processi
  2. Sincronizzazione dei thread

Qui discuteremo solo della sincronizzazione dei thread.

Sincronizzazione dei thread

Esistono due tipi di sincronizzazione dei thread, mutua esclusiva e comunicazione inter-thread.

  1. Mutua esclusiva
    1. Metodo sincronizzato.
    2. Blocco sincronizzato.
    3. Sincronizzazione statica.
  2. Cooperazione (comunicazione tra thread in Java)

Mutua esclusiva

L'esclusione reciproca aiuta a evitare che i thread interferiscano tra loro durante la condivisione dei dati. Può essere ottenuto utilizzando i seguenti tre modi:

  1. Utilizzando il metodo sincronizzato
  2. Utilizzando il blocco sincronizzato
  3. Utilizzando la sincronizzazione statica

Concetto di blocco in Java

La sincronizzazione è basata su un'entità interna nota come blocco o monitor. Ad ogni oggetto è associato un lucchetto. Per convenzione, un thread che necessita di un accesso coerente ai campi di un oggetto deve acquisire il blocco dell'oggetto prima di accedervi e quindi rilasciare il blocco quando ha finito con essi.

Da Java 5 il pacchetto java.util.concurrent.locks contiene diverse implementazioni di lock.

Comprendere il problema senza sincronizzazione

In questo esempio non c'è sincronizzazione, quindi l'output è incoerente. Vediamo l'esempio:

TestSynchronization1.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++){>

Metodo sincronizzato Java

Se dichiari un metodo come sincronizzato, è noto come metodo sincronizzato.

Il metodo sincronizzato viene utilizzato per bloccare un oggetto per qualsiasi risorsa condivisa.

Quando un thread invoca un metodo sincronizzato, acquisisce automaticamente il blocco per quell'oggetto e lo rilascia quando il thread completa la sua attività.

TestSynchronization2.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++){>

Esempio di metodo sincronizzato utilizzando la classe anonima

In questo programma abbiamo creato i due thread utilizzando la classe anonima, quindi è necessaria meno codifica.

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++){>