logo

TechCodeview

Sincronització en Java

La sincronització a Java és la capacitat de controlar l'accés de diversos fils a qualsevol recurs compartit.

La sincronització de Java és una millor opció quan volem permetre que només un fil accedeixi al recurs compartit.

Per què utilitzar la sincronització?

La sincronització s'utilitza principalment

  1. Per evitar interferències de fil.
  2. Per evitar problemes de coherència.

Tipus de sincronització

Hi ha dos tipus de sincronització

  1. Sincronització de processos
  2. Sincronització de fils

Aquí, parlarem només de la sincronització de fils.

Sincronització de fils

Hi ha dos tipus de sincronització de fils de comunicació excloent mútuament i entre fils.

  1. Exclusivitat mútua
    1. Mètode sincronitzat.
    2. Bloc sincronitzat.
    3. Sincronització estàtica.
  2. Cooperació (comunicació entre fils en java)

Exclusivitat mútua

L'exclusivitat mútua ajuda a evitar que els fils interfereixin entre si mentre comparteixen dades. Es pot aconseguir utilitzant les tres maneres següents:

  1. Mitjançant l'ús del mètode sincronitzat
  2. Mitjançant l'ús del bloc sincronitzat
  3. Mitjançant l'ús de la sincronització estàtica

Concepte de bloqueig a Java

La sincronització es construeix al voltant d'una entitat interna coneguda com a bloqueig o monitor. Cada objecte té un pany associat. Per convenció, un fil que necessita un accés coherent als camps d'un objecte ha d'adquirir el bloqueig de l'objecte abans d'accedir-hi, i després alliberar el bloqueig quan s'hagi fet amb ells.

Des de Java 5, el paquet java.util.concurrent.locks conté diverses implementacions de bloqueig.

Comprensió del problema sense sincronització

En aquest exemple, no hi ha sincronització, de manera que la sortida és inconsistent. Vegem l'exemple:

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

Mètode sincronitzat de Java

Si declareu qualsevol mètode com a sincronitzat, es coneix com a mètode sincronitzat.

El mètode sincronitzat s'utilitza per bloquejar un objecte per a qualsevol recurs compartit.

Quan un fil invoca un mètode sincronitzat, adquireix automàticament el bloqueig d'aquest objecte i l'allibera quan el fil completa la seva tasca.

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

Exemple de mètode sincronitzat mitjançant l'ús de classe anònima

En aquest programa, hem creat els dos fils utilitzant la classe anònima, de manera que es requereix menys codificació.

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